#include <cstddef>
/* setup return types that might not be defined */

#ifndef GL_VERSION_2_0
typedef char GLchar;
#endif

#ifndef GL_VERSION_1_5
typedef ptrdiff_t GLintptr;
typedef ptrdiff_t GLsizeiptr;
#endif

#ifndef GL_NV_half_float
typedef unsigned short GLhalfNV;
#endif

#ifndef GL_ARB_vertex_buffer_object
typedef ptrdiff_t GLintptrARB;
typedef ptrdiff_t GLsizeiptrARB;
#endif

#ifndef GL_ARB_shader_objects
typedef int GLhandleARB;
typedef char GLcharARB;
#endif

#ifndef GL_EXT_timer_query
typedef signed long long GLint64EXT;
typedef unsigned long long GLuint64EXT;
#endif

#ifdef _WIN32
// gl/gl defines GL_PHONG_WIN and GL_PHONG_HINT_WIN for us
#define GL_WIN_phong_shading              1

// gl/gl.h defines GL_FOG_SPECULAR_TEXTURE_WIN
#define GL_WIN_specular_fog               1

// defines GL_BYTE which is defined in gl/gl.h on windows
#define GL_OES_byte_coordinates           1
#endif


#define NAME_EMPTY(x)
#define FUNC_EMPTY(x, y, z, w)
#define END_EMPTY()
#define CONST_EMPTY(x, y)

      

#ifndef GL_VERSION_1_2
#define GL_VERSION_1_2 1
#define EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  NAME(GL_VERSION_1_2) \
  FUNC(void, glBlendColor, GLBLENDCOLOR, (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)) \
  FUNC(void, glBlendEquation, GLBLENDEQUATION, (GLenum mode)) \
  FUNC(void, glDrawRangeElements, GLDRAWRANGEELEMENTS, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)) \
  FUNC(void, glColorTable, GLCOLORTABLE, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)) \
  FUNC(void, glColorTableParameterfv, GLCOLORTABLEPARAMETERFV, (GLenum target, GLenum pname, const GLfloat * params)) \
  FUNC(void, glColorTableParameteriv, GLCOLORTABLEPARAMETERIV, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glCopyColorTable, GLCOPYCOLORTABLE, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
  FUNC(void, glGetColorTable, GLGETCOLORTABLE, (GLenum target, GLenum format, GLenum type, GLvoid * table)) \
  FUNC(void, glGetColorTableParameterfv, GLGETCOLORTABLEPARAMETERFV, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetColorTableParameteriv, GLGETCOLORTABLEPARAMETERIV, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glColorSubTable, GLCOLORSUBTABLE, (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)) \
  FUNC(void, glCopyColorSubTable, GLCOPYCOLORSUBTABLE, (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)) \
  FUNC(void, glConvolutionFilter1D, GLCONVOLUTIONFILTER1D, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)) \
  FUNC(void, glConvolutionFilter2D, GLCONVOLUTIONFILTER2D, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)) \
  FUNC(void, glConvolutionParameterf, GLCONVOLUTIONPARAMETERF, (GLenum target, GLenum pname, GLfloat params)) \
  FUNC(void, glConvolutionParameterfv, GLCONVOLUTIONPARAMETERFV, (GLenum target, GLenum pname, const GLfloat * params)) \
  FUNC(void, glConvolutionParameteri, GLCONVOLUTIONPARAMETERI, (GLenum target, GLenum pname, GLint params)) \
  FUNC(void, glConvolutionParameteriv, GLCONVOLUTIONPARAMETERIV, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glCopyConvolutionFilter1D, GLCOPYCONVOLUTIONFILTER1D, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
  FUNC(void, glCopyConvolutionFilter2D, GLCOPYCONVOLUTIONFILTER2D, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)) \
  FUNC(void, glGetConvolutionFilter, GLGETCONVOLUTIONFILTER, (GLenum target, GLenum format, GLenum type, GLvoid * image)) \
  FUNC(void, glGetConvolutionParameterfv, GLGETCONVOLUTIONPARAMETERFV, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetConvolutionParameteriv, GLGETCONVOLUTIONPARAMETERIV, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetSeparableFilter, GLGETSEPARABLEFILTER, (GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)) \
  FUNC(void, glSeparableFilter2D, GLSEPARABLEFILTER2D, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)) \
  FUNC(void, glGetHistogram, GLGETHISTOGRAM, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)) \
  FUNC(void, glGetHistogramParameterfv, GLGETHISTOGRAMPARAMETERFV, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetHistogramParameteriv, GLGETHISTOGRAMPARAMETERIV, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetMinmax, GLGETMINMAX, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)) \
  FUNC(void, glGetMinmaxParameterfv, GLGETMINMAXPARAMETERFV, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetMinmaxParameteriv, GLGETMINMAXPARAMETERIV, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glHistogram, GLHISTOGRAM, (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)) \
  FUNC(void, glMinmax, GLMINMAX, (GLenum target, GLenum internalformat, GLboolean sink)) \
  FUNC(void, glResetHistogram, GLRESETHISTOGRAM, (GLenum target)) \
  FUNC(void, glResetMinmax, GLRESETMINMAX, (GLenum target)) \
  FUNC(void, glTexImage3D, GLTEXIMAGE3D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)) \
  FUNC(void, glTexSubImage3D, GLTEXSUBIMAGE3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)) \
  FUNC(void, glCopyTexSubImage3D, GLCOPYTEXSUBIMAGE3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
  CONST(GL_UNSIGNED_BYTE_3_3_2, 0x8032) \
  CONST(GL_UNSIGNED_SHORT_4_4_4_4, 0x8033) \
  CONST(GL_UNSIGNED_SHORT_5_5_5_1, 0x8034) \
  CONST(GL_UNSIGNED_INT_8_8_8_8, 0x8035) \
  CONST(GL_UNSIGNED_INT_10_10_10_2, 0x8036) \
  CONST(GL_RESCALE_NORMAL, 0x803A) \
  CONST(GL_TEXTURE_BINDING_3D, 0x806A) \
  CONST(GL_PACK_SKIP_IMAGES, 0x806B) \
  CONST(GL_PACK_IMAGE_HEIGHT, 0x806C) \
  CONST(GL_UNPACK_SKIP_IMAGES, 0x806D) \
  CONST(GL_UNPACK_IMAGE_HEIGHT, 0x806E) \
  CONST(GL_TEXTURE_3D, 0x806F) \
  CONST(GL_PROXY_TEXTURE_3D, 0x8070) \
  CONST(GL_TEXTURE_DEPTH, 0x8071) \
  CONST(GL_TEXTURE_WRAP_R, 0x8072) \
  CONST(GL_MAX_3D_TEXTURE_SIZE, 0x8073) \
  CONST(GL_UNSIGNED_BYTE_2_3_3_REV, 0x8362) \
  CONST(GL_UNSIGNED_SHORT_5_6_5, 0x8363) \
  CONST(GL_UNSIGNED_SHORT_5_6_5_REV, 0x8364) \
  CONST(GL_UNSIGNED_SHORT_4_4_4_4_REV, 0x8365) \
  CONST(GL_UNSIGNED_SHORT_1_5_5_5_REV, 0x8366) \
  CONST(GL_UNSIGNED_INT_8_8_8_8_REV, 0x8367) \
  CONST(GL_UNSIGNED_INT_2_10_10_10_REV, 0x8368) \
  CONST(GL_BGR, 0x80E0) \
  CONST(GL_BGRA, 0x80E1) \
  CONST(GL_MAX_ELEMENTS_VERTICES, 0x80E8) \
  CONST(GL_MAX_ELEMENTS_INDICES, 0x80E9) \
  CONST(GL_CLAMP_TO_EDGE, 0x812F) \
  CONST(GL_TEXTURE_MIN_LOD, 0x813A) \
  CONST(GL_TEXTURE_MAX_LOD, 0x813B) \
  CONST(GL_TEXTURE_BASE_LEVEL, 0x813C) \
  CONST(GL_TEXTURE_MAX_LEVEL, 0x813D) \
  CONST(GL_LIGHT_MODEL_COLOR_CONTROL, 0x81F8) \
  CONST(GL_SINGLE_COLOR, 0x81F9) \
  CONST(GL_SEPARATE_SPECULAR_COLOR, 0x81FA) \
  CONST(GL_SMOOTH_POINT_SIZE_RANGE, 0x0B12) \
  CONST(GL_SMOOTH_POINT_SIZE_GRANULARITY, 0x0B13) \
  CONST(GL_SMOOTH_LINE_WIDTH_RANGE, 0x0B22) \
  CONST(GL_SMOOTH_LINE_WIDTH_GRANULARITY, 0x0B23) \
  CONST(GL_ALIASED_POINT_SIZE_RANGE, 0x846D) \
  CONST(GL_ALIASED_LINE_WIDTH_RANGE, 0x846E) \
  END()
#else
#define EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_imaging
#define GL_ARB_imaging 1
#define EXTENSION_GL_ARB_imaging(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_imaging) \
  CONST(GL_CONSTANT_COLOR, 0x8001) \
  CONST(GL_ONE_MINUS_CONSTANT_COLOR, 0x8002) \
  CONST(GL_CONSTANT_ALPHA, 0x8003) \
  CONST(GL_ONE_MINUS_CONSTANT_ALPHA, 0x8004) \
  CONST(GL_BLEND_COLOR, 0x8005) \
  CONST(GL_FUNC_ADD, 0x8006) \
  CONST(GL_MIN, 0x8007) \
  CONST(GL_MAX, 0x8008) \
  CONST(GL_BLEND_EQUATION, 0x8009) \
  CONST(GL_FUNC_SUBTRACT, 0x800A) \
  CONST(GL_FUNC_REVERSE_SUBTRACT, 0x800B) \
  CONST(GL_CONVOLUTION_1D, 0x8010) \
  CONST(GL_CONVOLUTION_2D, 0x8011) \
  CONST(GL_SEPARABLE_2D, 0x8012) \
  CONST(GL_CONVOLUTION_BORDER_MODE, 0x8013) \
  CONST(GL_CONVOLUTION_FILTER_SCALE, 0x8014) \
  CONST(GL_CONVOLUTION_FILTER_BIAS, 0x8015) \
  CONST(GL_REDUCE, 0x8016) \
  CONST(GL_CONVOLUTION_FORMAT, 0x8017) \
  CONST(GL_CONVOLUTION_WIDTH, 0x8018) \
  CONST(GL_CONVOLUTION_HEIGHT, 0x8019) \
  CONST(GL_MAX_CONVOLUTION_WIDTH, 0x801A) \
  CONST(GL_MAX_CONVOLUTION_HEIGHT, 0x801B) \
  CONST(GL_POST_CONVOLUTION_RED_SCALE, 0x801C) \
  CONST(GL_POST_CONVOLUTION_GREEN_SCALE, 0x801D) \
  CONST(GL_POST_CONVOLUTION_BLUE_SCALE, 0x801E) \
  CONST(GL_POST_CONVOLUTION_ALPHA_SCALE, 0x801F) \
  CONST(GL_POST_CONVOLUTION_RED_BIAS, 0x8020) \
  CONST(GL_POST_CONVOLUTION_GREEN_BIAS, 0x8021) \
  CONST(GL_POST_CONVOLUTION_BLUE_BIAS, 0x8022) \
  CONST(GL_POST_CONVOLUTION_ALPHA_BIAS, 0x8023) \
  CONST(GL_HISTOGRAM, 0x8024) \
  CONST(GL_PROXY_HISTOGRAM, 0x8025) \
  CONST(GL_HISTOGRAM_WIDTH, 0x8026) \
  CONST(GL_HISTOGRAM_FORMAT, 0x8027) \
  CONST(GL_HISTOGRAM_RED_SIZE, 0x8028) \
  CONST(GL_HISTOGRAM_GREEN_SIZE, 0x8029) \
  CONST(GL_HISTOGRAM_BLUE_SIZE, 0x802A) \
  CONST(GL_HISTOGRAM_ALPHA_SIZE, 0x802B) \
  CONST(GL_HISTOGRAM_LUMINANCE_SIZE, 0x802C) \
  CONST(GL_HISTOGRAM_SINK, 0x802D) \
  CONST(GL_MINMAX, 0x802E) \
  CONST(GL_MINMAX_FORMAT, 0x802F) \
  CONST(GL_MINMAX_SINK, 0x8030) \
  CONST(GL_TABLE_TOO_LARGE, 0x8031) \
  CONST(GL_COLOR_MATRIX, 0x80B1) \
  CONST(GL_COLOR_MATRIX_STACK_DEPTH, 0x80B2) \
  CONST(GL_MAX_COLOR_MATRIX_STACK_DEPTH, 0x80B3) \
  CONST(GL_POST_COLOR_MATRIX_RED_SCALE, 0x80B4) \
  CONST(GL_POST_COLOR_MATRIX_GREEN_SCALE, 0x80B5) \
  CONST(GL_POST_COLOR_MATRIX_BLUE_SCALE, 0x80B6) \
  CONST(GL_POST_COLOR_MATRIX_ALPHA_SCALE, 0x80B7) \
  CONST(GL_POST_COLOR_MATRIX_RED_BIAS, 0x80B8) \
  CONST(GL_POST_COLOR_MATRIX_GREEN_BIAS, 0x80B9) \
  CONST(GL_POST_COLOR_MATRIX_BLUE_BIAS, 0x80BA) \
  CONST(GL_POST_COLOR_MATRIX_ALPHA_BIAS, 0x80BB) \
  CONST(GL_COLOR_TABLE, 0x80D0) \
  CONST(GL_POST_CONVOLUTION_COLOR_TABLE, 0x80D1) \
  CONST(GL_POST_COLOR_MATRIX_COLOR_TABLE, 0x80D2) \
  CONST(GL_PROXY_COLOR_TABLE, 0x80D3) \
  CONST(GL_PROXY_POST_CONVOLUTION_COLOR_TABLE, 0x80D4) \
  CONST(GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE, 0x80D5) \
  CONST(GL_COLOR_TABLE_SCALE, 0x80D6) \
  CONST(GL_COLOR_TABLE_BIAS, 0x80D7) \
  CONST(GL_COLOR_TABLE_FORMAT, 0x80D8) \
  CONST(GL_COLOR_TABLE_WIDTH, 0x80D9) \
  CONST(GL_COLOR_TABLE_RED_SIZE, 0x80DA) \
  CONST(GL_COLOR_TABLE_GREEN_SIZE, 0x80DB) \
  CONST(GL_COLOR_TABLE_BLUE_SIZE, 0x80DC) \
  CONST(GL_COLOR_TABLE_ALPHA_SIZE, 0x80DD) \
  CONST(GL_COLOR_TABLE_LUMINANCE_SIZE, 0x80DE) \
  CONST(GL_COLOR_TABLE_INTENSITY_SIZE, 0x80DF) \
  CONST(GL_CONSTANT_BORDER, 0x8151) \
  CONST(GL_REPLICATE_BORDER, 0x8153) \
  CONST(GL_CONVOLUTION_BORDER_COLOR, 0x8154) \
  END()
#else
#define EXTENSION_GL_ARB_imaging(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_VERSION_1_3
#define GL_VERSION_1_3 1
#define EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \
  NAME(GL_VERSION_1_3) \
  FUNC(void, glActiveTexture, GLACTIVETEXTURE, (GLenum texture)) \
  FUNC(void, glClientActiveTexture, GLCLIENTACTIVETEXTURE, (GLenum texture)) \
  FUNC(void, glMultiTexCoord1d, GLMULTITEXCOORD1D, (GLenum target, GLdouble s)) \
  FUNC(void, glMultiTexCoord1dv, GLMULTITEXCOORD1DV, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord1f, GLMULTITEXCOORD1F, (GLenum target, GLfloat s)) \
  FUNC(void, glMultiTexCoord1fv, GLMULTITEXCOORD1FV, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord1i, GLMULTITEXCOORD1I, (GLenum target, GLint s)) \
  FUNC(void, glMultiTexCoord1iv, GLMULTITEXCOORD1IV, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord1s, GLMULTITEXCOORD1S, (GLenum target, GLshort s)) \
  FUNC(void, glMultiTexCoord1sv, GLMULTITEXCOORD1SV, (GLenum target, const GLshort * v)) \
  FUNC(void, glMultiTexCoord2d, GLMULTITEXCOORD2D, (GLenum target, GLdouble s, GLdouble t)) \
  FUNC(void, glMultiTexCoord2dv, GLMULTITEXCOORD2DV, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord2f, GLMULTITEXCOORD2F, (GLenum target, GLfloat s, GLfloat t)) \
  FUNC(void, glMultiTexCoord2fv, GLMULTITEXCOORD2FV, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord2i, GLMULTITEXCOORD2I, (GLenum target, GLint s, GLint t)) \
  FUNC(void, glMultiTexCoord2iv, GLMULTITEXCOORD2IV, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord2s, GLMULTITEXCOORD2S, (GLenum target, GLshort s, GLshort t)) \
  FUNC(void, glMultiTexCoord2sv, GLMULTITEXCOORD2SV, (GLenum target, const GLshort * v)) \
  FUNC(void, glMultiTexCoord3d, GLMULTITEXCOORD3D, (GLenum target, GLdouble s, GLdouble t, GLdouble r)) \
  FUNC(void, glMultiTexCoord3dv, GLMULTITEXCOORD3DV, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord3f, GLMULTITEXCOORD3F, (GLenum target, GLfloat s, GLfloat t, GLfloat r)) \
  FUNC(void, glMultiTexCoord3fv, GLMULTITEXCOORD3FV, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord3i, GLMULTITEXCOORD3I, (GLenum target, GLint s, GLint t, GLint r)) \
  FUNC(void, glMultiTexCoord3iv, GLMULTITEXCOORD3IV, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord3s, GLMULTITEXCOORD3S, (GLenum target, GLshort s, GLshort t, GLshort r)) \
  FUNC(void, glMultiTexCoord3sv, GLMULTITEXCOORD3SV, (GLenum target, const GLshort * v)) \
  FUNC(void, glMultiTexCoord4d, GLMULTITEXCOORD4D, (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)) \
  FUNC(void, glMultiTexCoord4dv, GLMULTITEXCOORD4DV, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord4f, GLMULTITEXCOORD4F, (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)) \
  FUNC(void, glMultiTexCoord4fv, GLMULTITEXCOORD4FV, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord4i, GLMULTITEXCOORD4I, (GLenum target, GLint s, GLint t, GLint r, GLint q)) \
  FUNC(void, glMultiTexCoord4iv, GLMULTITEXCOORD4IV, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord4s, GLMULTITEXCOORD4S, (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)) \
  FUNC(void, glMultiTexCoord4sv, GLMULTITEXCOORD4SV, (GLenum target, const GLshort * v)) \
  FUNC(void, glLoadTransposeMatrixf, GLLOADTRANSPOSEMATRIXF, (const GLfloat * m)) \
  FUNC(void, glLoadTransposeMatrixd, GLLOADTRANSPOSEMATRIXD, (const GLdouble * m)) \
  FUNC(void, glMultTransposeMatrixf, GLMULTTRANSPOSEMATRIXF, (const GLfloat * m)) \
  FUNC(void, glMultTransposeMatrixd, GLMULTTRANSPOSEMATRIXD, (const GLdouble * m)) \
  FUNC(void, glSampleCoverage, GLSAMPLECOVERAGE, (GLclampf value, GLboolean invert)) \
  FUNC(void, glCompressedTexImage3D, GLCOMPRESSEDTEXIMAGE3D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexImage2D, GLCOMPRESSEDTEXIMAGE2D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexImage1D, GLCOMPRESSEDTEXIMAGE1D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexSubImage3D, GLCOMPRESSEDTEXSUBIMAGE3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexSubImage2D, GLCOMPRESSEDTEXSUBIMAGE2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexSubImage1D, GLCOMPRESSEDTEXSUBIMAGE1D, (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glGetCompressedTexImage, GLGETCOMPRESSEDTEXIMAGE, (GLenum target, GLint level, GLvoid * img)) \
  CONST(GL_TEXTURE0, 0x84C0) \
  CONST(GL_TEXTURE1, 0x84C1) \
  CONST(GL_TEXTURE2, 0x84C2) \
  CONST(GL_TEXTURE3, 0x84C3) \
  CONST(GL_TEXTURE4, 0x84C4) \
  CONST(GL_TEXTURE5, 0x84C5) \
  CONST(GL_TEXTURE6, 0x84C6) \
  CONST(GL_TEXTURE7, 0x84C7) \
  CONST(GL_TEXTURE8, 0x84C8) \
  CONST(GL_TEXTURE9, 0x84C9) \
  CONST(GL_TEXTURE10, 0x84CA) \
  CONST(GL_TEXTURE11, 0x84CB) \
  CONST(GL_TEXTURE12, 0x84CC) \
  CONST(GL_TEXTURE13, 0x84CD) \
  CONST(GL_TEXTURE14, 0x84CE) \
  CONST(GL_TEXTURE15, 0x84CF) \
  CONST(GL_TEXTURE16, 0x84D0) \
  CONST(GL_TEXTURE17, 0x84D1) \
  CONST(GL_TEXTURE18, 0x84D2) \
  CONST(GL_TEXTURE19, 0x84D3) \
  CONST(GL_TEXTURE20, 0x84D4) \
  CONST(GL_TEXTURE21, 0x84D5) \
  CONST(GL_TEXTURE22, 0x84D6) \
  CONST(GL_TEXTURE23, 0x84D7) \
  CONST(GL_TEXTURE24, 0x84D8) \
  CONST(GL_TEXTURE25, 0x84D9) \
  CONST(GL_TEXTURE26, 0x84DA) \
  CONST(GL_TEXTURE27, 0x84DB) \
  CONST(GL_TEXTURE28, 0x84DC) \
  CONST(GL_TEXTURE29, 0x84DD) \
  CONST(GL_TEXTURE30, 0x84DE) \
  CONST(GL_TEXTURE31, 0x84DF) \
  CONST(GL_ACTIVE_TEXTURE, 0x84E0) \
  CONST(GL_CLIENT_ACTIVE_TEXTURE, 0x84E1) \
  CONST(GL_MAX_TEXTURE_UNITS, 0x84E2) \
  CONST(GL_TRANSPOSE_MODELVIEW_MATRIX, 0x84E3) \
  CONST(GL_TRANSPOSE_PROJECTION_MATRIX, 0x84E4) \
  CONST(GL_TRANSPOSE_TEXTURE_MATRIX, 0x84E5) \
  CONST(GL_TRANSPOSE_COLOR_MATRIX, 0x84E6) \
  CONST(GL_MULTISAMPLE, 0x809D) \
  CONST(GL_SAMPLE_ALPHA_TO_COVERAGE, 0x809E) \
  CONST(GL_SAMPLE_ALPHA_TO_ONE, 0x809F) \
  CONST(GL_SAMPLE_COVERAGE, 0x80A0) \
  CONST(GL_SAMPLE_BUFFERS, 0x80A8) \
  CONST(GL_SAMPLES, 0x80A9) \
  CONST(GL_SAMPLE_COVERAGE_VALUE, 0x80AA) \
  CONST(GL_SAMPLE_COVERAGE_INVERT, 0x80AB) \
  CONST(GL_MULTISAMPLE_BIT, 0x20000000) \
  CONST(GL_NORMAL_MAP, 0x8511) \
  CONST(GL_REFLECTION_MAP, 0x8512) \
  CONST(GL_TEXTURE_CUBE_MAP, 0x8513) \
  CONST(GL_TEXTURE_BINDING_CUBE_MAP, 0x8514) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0x8515) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0x8516) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0x8517) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0x8518) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0x8519) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0x851A) \
  CONST(GL_PROXY_TEXTURE_CUBE_MAP, 0x851B) \
  CONST(GL_MAX_CUBE_MAP_TEXTURE_SIZE, 0x851C) \
  CONST(GL_COMPRESSED_ALPHA, 0x84E9) \
  CONST(GL_COMPRESSED_LUMINANCE, 0x84EA) \
  CONST(GL_COMPRESSED_LUMINANCE_ALPHA, 0x84EB) \
  CONST(GL_COMPRESSED_INTENSITY, 0x84EC) \
  CONST(GL_COMPRESSED_RGB, 0x84ED) \
  CONST(GL_COMPRESSED_RGBA, 0x84EE) \
  CONST(GL_TEXTURE_COMPRESSION_HINT, 0x84EF) \
  CONST(GL_TEXTURE_COMPRESSED_IMAGE_SIZE, 0x86A0) \
  CONST(GL_TEXTURE_COMPRESSED, 0x86A1) \
  CONST(GL_NUM_COMPRESSED_TEXTURE_FORMATS, 0x86A2) \
  CONST(GL_COMPRESSED_TEXTURE_FORMATS, 0x86A3) \
  CONST(GL_CLAMP_TO_BORDER, 0x812D) \
  CONST(GL_COMBINE, 0x8570) \
  CONST(GL_COMBINE_RGB, 0x8571) \
  CONST(GL_COMBINE_ALPHA, 0x8572) \
  CONST(GL_SOURCE0_RGB, 0x8580) \
  CONST(GL_SOURCE1_RGB, 0x8581) \
  CONST(GL_SOURCE2_RGB, 0x8582) \
  CONST(GL_SOURCE0_ALPHA, 0x8588) \
  CONST(GL_SOURCE1_ALPHA, 0x8589) \
  CONST(GL_SOURCE2_ALPHA, 0x858A) \
  CONST(GL_OPERAND0_RGB, 0x8590) \
  CONST(GL_OPERAND1_RGB, 0x8591) \
  CONST(GL_OPERAND2_RGB, 0x8592) \
  CONST(GL_OPERAND0_ALPHA, 0x8598) \
  CONST(GL_OPERAND1_ALPHA, 0x8599) \
  CONST(GL_OPERAND2_ALPHA, 0x859A) \
  CONST(GL_RGB_SCALE, 0x8573) \
  CONST(GL_ADD_SIGNED, 0x8574) \
  CONST(GL_INTERPOLATE, 0x8575) \
  CONST(GL_SUBTRACT, 0x84E7) \
  CONST(GL_CONSTANT, 0x8576) \
  CONST(GL_PRIMARY_COLOR, 0x8577) \
  CONST(GL_PREVIOUS, 0x8578) \
  CONST(GL_DOT3_RGB, 0x86AE) \
  CONST(GL_DOT3_RGBA, 0x86AF) \
  END()
#else
#define EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_VERSION_1_4
#define GL_VERSION_1_4 1
#define EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END) \
  NAME(GL_VERSION_1_4) \
  FUNC(void, glBlendFuncSeparate, GLBLENDFUNCSEPARATE, (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)) \
  FUNC(void, glFogCoordf, GLFOGCOORDF, (GLfloat coord)) \
  FUNC(void, glFogCoordfv, GLFOGCOORDFV, (const GLfloat * coord)) \
  FUNC(void, glFogCoordd, GLFOGCOORDD, (GLdouble coord)) \
  FUNC(void, glFogCoorddv, GLFOGCOORDDV, (const GLdouble * coord)) \
  FUNC(void, glFogCoordPointer, GLFOGCOORDPOINTER, (GLenum type, GLsizei stride, const GLvoid * pointer)) \
  FUNC(void, glMultiDrawArrays, GLMULTIDRAWARRAYS, (GLenum mode, GLint * first, GLsizei * count, GLsizei primcount)) \
  FUNC(void, glMultiDrawElements, GLMULTIDRAWELEMENTS, (GLenum mode, const GLsizei * count, GLenum type, const GLvoid* * indices, GLsizei primcount)) \
  FUNC(void, glPointParameterf, GLPOINTPARAMETERF, (GLenum pname, GLfloat param)) \
  FUNC(void, glPointParameterfv, GLPOINTPARAMETERFV, (GLenum pname, const GLfloat * params)) \
  FUNC(void, glPointParameteri, GLPOINTPARAMETERI, (GLenum pname, GLint param)) \
  FUNC(void, glPointParameteriv, GLPOINTPARAMETERIV, (GLenum pname, const GLint * params)) \
  FUNC(void, glSecondaryColor3b, GLSECONDARYCOLOR3B, (GLbyte red, GLbyte green, GLbyte blue)) \
  FUNC(void, glSecondaryColor3bv, GLSECONDARYCOLOR3BV, (const GLbyte * v)) \
  FUNC(void, glSecondaryColor3d, GLSECONDARYCOLOR3D, (GLdouble red, GLdouble green, GLdouble blue)) \
  FUNC(void, glSecondaryColor3dv, GLSECONDARYCOLOR3DV, (const GLdouble * v)) \
  FUNC(void, glSecondaryColor3f, GLSECONDARYCOLOR3F, (GLfloat red, GLfloat green, GLfloat blue)) \
  FUNC(void, glSecondaryColor3fv, GLSECONDARYCOLOR3FV, (const GLfloat * v)) \
  FUNC(void, glSecondaryColor3i, GLSECONDARYCOLOR3I, (GLint red, GLint green, GLint blue)) \
  FUNC(void, glSecondaryColor3iv, GLSECONDARYCOLOR3IV, (const GLint * v)) \
  FUNC(void, glSecondaryColor3s, GLSECONDARYCOLOR3S, (GLshort red, GLshort green, GLshort blue)) \
  FUNC(void, glSecondaryColor3sv, GLSECONDARYCOLOR3SV, (const GLshort * v)) \
  FUNC(void, glSecondaryColor3ub, GLSECONDARYCOLOR3UB, (GLubyte red, GLubyte green, GLubyte blue)) \
  FUNC(void, glSecondaryColor3ubv, GLSECONDARYCOLOR3UBV, (const GLubyte * v)) \
  FUNC(void, glSecondaryColor3ui, GLSECONDARYCOLOR3UI, (GLuint red, GLuint green, GLuint blue)) \
  FUNC(void, glSecondaryColor3uiv, GLSECONDARYCOLOR3UIV, (const GLuint * v)) \
  FUNC(void, glSecondaryColor3us, GLSECONDARYCOLOR3US, (GLushort red, GLushort green, GLushort blue)) \
  FUNC(void, glSecondaryColor3usv, GLSECONDARYCOLOR3USV, (const GLushort * v)) \
  FUNC(void, glSecondaryColorPointer, GLSECONDARYCOLORPOINTER, (GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)) \
  FUNC(void, glWindowPos2d, GLWINDOWPOS2D, (GLdouble x, GLdouble y)) \
  FUNC(void, glWindowPos2dv, GLWINDOWPOS2DV, (const GLdouble * v)) \
  FUNC(void, glWindowPos2f, GLWINDOWPOS2F, (GLfloat x, GLfloat y)) \
  FUNC(void, glWindowPos2fv, GLWINDOWPOS2FV, (const GLfloat * v)) \
  FUNC(void, glWindowPos2i, GLWINDOWPOS2I, (GLint x, GLint y)) \
  FUNC(void, glWindowPos2iv, GLWINDOWPOS2IV, (const GLint * v)) \
  FUNC(void, glWindowPos2s, GLWINDOWPOS2S, (GLshort x, GLshort y)) \
  FUNC(void, glWindowPos2sv, GLWINDOWPOS2SV, (const GLshort * v)) \
  FUNC(void, glWindowPos3d, GLWINDOWPOS3D, (GLdouble x, GLdouble y, GLdouble z)) \
  FUNC(void, glWindowPos3dv, GLWINDOWPOS3DV, (const GLdouble * v)) \
  FUNC(void, glWindowPos3f, GLWINDOWPOS3F, (GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glWindowPos3fv, GLWINDOWPOS3FV, (const GLfloat * v)) \
  FUNC(void, glWindowPos3i, GLWINDOWPOS3I, (GLint x, GLint y, GLint z)) \
  FUNC(void, glWindowPos3iv, GLWINDOWPOS3IV, (const GLint * v)) \
  FUNC(void, glWindowPos3s, GLWINDOWPOS3S, (GLshort x, GLshort y, GLshort z)) \
  FUNC(void, glWindowPos3sv, GLWINDOWPOS3SV, (const GLshort * v)) \
  CONST(GL_BLEND_DST_RGB, 0x80C8) \
  CONST(GL_BLEND_SRC_RGB, 0x80C9) \
  CONST(GL_BLEND_DST_ALPHA, 0x80CA) \
  CONST(GL_BLEND_SRC_ALPHA, 0x80CB) \
  CONST(GL_POINT_SIZE_MIN, 0x8126) \
  CONST(GL_POINT_SIZE_MAX, 0x8127) \
  CONST(GL_POINT_FADE_THRESHOLD_SIZE, 0x8128) \
  CONST(GL_POINT_DISTANCE_ATTENUATION, 0x8129) \
  CONST(GL_GENERATE_MIPMAP, 0x8191) \
  CONST(GL_GENERATE_MIPMAP_HINT, 0x8192) \
  CONST(GL_DEPTH_COMPONENT16, 0x81A5) \
  CONST(GL_DEPTH_COMPONENT24, 0x81A6) \
  CONST(GL_DEPTH_COMPONENT32, 0x81A7) \
  CONST(GL_MIRRORED_REPEAT, 0x8370) \
  CONST(GL_FOG_COORDINATE_SOURCE, 0x8450) \
  CONST(GL_FOG_COORDINATE, 0x8451) \
  CONST(GL_FRAGMENT_DEPTH, 0x8452) \
  CONST(GL_CURRENT_FOG_COORDINATE, 0x8453) \
  CONST(GL_FOG_COORDINATE_ARRAY_TYPE, 0x8454) \
  CONST(GL_FOG_COORDINATE_ARRAY_STRIDE, 0x8455) \
  CONST(GL_FOG_COORDINATE_ARRAY_POINTER, 0x8456) \
  CONST(GL_FOG_COORDINATE_ARRAY, 0x8457) \
  CONST(GL_COLOR_SUM, 0x8458) \
  CONST(GL_CURRENT_SECONDARY_COLOR, 0x8459) \
  CONST(GL_SECONDARY_COLOR_ARRAY_SIZE, 0x845A) \
  CONST(GL_SECONDARY_COLOR_ARRAY_TYPE, 0x845B) \
  CONST(GL_SECONDARY_COLOR_ARRAY_STRIDE, 0x845C) \
  CONST(GL_SECONDARY_COLOR_ARRAY_POINTER, 0x845D) \
  CONST(GL_SECONDARY_COLOR_ARRAY, 0x845E) \
  CONST(GL_MAX_TEXTURE_LOD_BIAS, 0x84FD) \
  CONST(GL_TEXTURE_FILTER_CONTROL, 0x8500) \
  CONST(GL_TEXTURE_LOD_BIAS, 0x8501) \
  CONST(GL_INCR_WRAP, 0x8507) \
  CONST(GL_DECR_WRAP, 0x8508) \
  CONST(GL_TEXTURE_DEPTH_SIZE, 0x884A) \
  CONST(GL_DEPTH_TEXTURE_MODE, 0x884B) \
  CONST(GL_TEXTURE_COMPARE_MODE, 0x884C) \
  CONST(GL_TEXTURE_COMPARE_FUNC, 0x884D) \
  CONST(GL_COMPARE_R_TO_TEXTURE, 0x884E) \
  END()
#else
#define EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_VERSION_1_5
#define GL_VERSION_1_5 1
#define EXTENSION_GL_VERSION_1_5(NAME, FUNC, CONST, END) \
  NAME(GL_VERSION_1_5) \
  FUNC(void, glGenQueries, GLGENQUERIES, (GLsizei n, GLuint * ids)) \
  FUNC(void, glDeleteQueries, GLDELETEQUERIES, (GLsizei n, const GLuint * ids)) \
  FUNC(GLboolean, glIsQuery, GLISQUERY, (GLuint id)) \
  FUNC(void, glBeginQuery, GLBEGINQUERY, (GLenum target, GLuint id)) \
  FUNC(void, glEndQuery, GLENDQUERY, (GLenum target)) \
  FUNC(void, glGetQueryiv, GLGETQUERYIV, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetQueryObjectiv, GLGETQUERYOBJECTIV, (GLuint id, GLenum pname, GLint * params)) \
  FUNC(void, glGetQueryObjectuiv, GLGETQUERYOBJECTUIV, (GLuint id, GLenum pname, GLuint * params)) \
  FUNC(void, glBindBuffer, GLBINDBUFFER, (GLenum target, GLuint buffer)) \
  FUNC(void, glDeleteBuffers, GLDELETEBUFFERS, (GLsizei n, const GLuint * buffers)) \
  FUNC(void, glGenBuffers, GLGENBUFFERS, (GLsizei n, GLuint * buffers)) \
  FUNC(GLboolean, glIsBuffer, GLISBUFFER, (GLuint buffer)) \
  FUNC(void, glBufferData, GLBUFFERDATA, (GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage)) \
  FUNC(void, glBufferSubData, GLBUFFERSUBDATA, (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)) \
  FUNC(void, glGetBufferSubData, GLGETBUFFERSUBDATA, (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data)) \
  FUNC(GLvoid*, glMapBuffer, GLMAPBUFFER, (GLenum target, GLenum access)) \
  FUNC(GLboolean, glUnmapBuffer, GLUNMAPBUFFER, (GLenum target)) \
  FUNC(void, glGetBufferParameteriv, GLGETBUFFERPARAMETERIV, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetBufferPointerv, GLGETBUFFERPOINTERV, (GLenum target, GLenum pname, GLvoid* * params)) \
  CONST(GL_BUFFER_SIZE, 0x8764) \
  CONST(GL_BUFFER_USAGE, 0x8765) \
  CONST(GL_QUERY_COUNTER_BITS, 0x8864) \
  CONST(GL_CURRENT_QUERY, 0x8865) \
  CONST(GL_QUERY_RESULT, 0x8866) \
  CONST(GL_QUERY_RESULT_AVAILABLE, 0x8867) \
  CONST(GL_ARRAY_BUFFER, 0x8892) \
  CONST(GL_ELEMENT_ARRAY_BUFFER, 0x8893) \
  CONST(GL_ARRAY_BUFFER_BINDING, 0x8894) \
  CONST(GL_ELEMENT_ARRAY_BUFFER_BINDING, 0x8895) \
  CONST(GL_VERTEX_ARRAY_BUFFER_BINDING, 0x8896) \
  CONST(GL_NORMAL_ARRAY_BUFFER_BINDING, 0x8897) \
  CONST(GL_COLOR_ARRAY_BUFFER_BINDING, 0x8898) \
  CONST(GL_INDEX_ARRAY_BUFFER_BINDING, 0x8899) \
  CONST(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING, 0x889A) \
  CONST(GL_EDGE_FLAG_ARRAY_BUFFER_BINDING, 0x889B) \
  CONST(GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING, 0x889C) \
  CONST(GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING, 0x889D) \
  CONST(GL_WEIGHT_ARRAY_BUFFER_BINDING, 0x889E) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, 0x889F) \
  CONST(GL_READ_ONLY, 0x88B8) \
  CONST(GL_WRITE_ONLY, 0x88B9) \
  CONST(GL_READ_WRITE, 0x88BA) \
  CONST(GL_BUFFER_ACCESS, 0x88BB) \
  CONST(GL_BUFFER_MAPPED, 0x88BC) \
  CONST(GL_BUFFER_MAP_POINTER, 0x88BD) \
  CONST(GL_STREAM_DRAW, 0x88E0) \
  CONST(GL_STREAM_READ, 0x88E1) \
  CONST(GL_STREAM_COPY, 0x88E2) \
  CONST(GL_STATIC_DRAW, 0x88E4) \
  CONST(GL_STATIC_READ, 0x88E5) \
  CONST(GL_STATIC_COPY, 0x88E6) \
  CONST(GL_DYNAMIC_DRAW, 0x88E8) \
  CONST(GL_DYNAMIC_READ, 0x88E9) \
  CONST(GL_DYNAMIC_COPY, 0x88EA) \
  CONST(GL_SAMPLES_PASSED, 0x8914) \
  CONST(GL_FOG_COORD_SRC, GL_FOG_COORDINATE_SOURCE) \
  CONST(GL_FOG_COORD, GL_FOG_COORDINATE) \
  CONST(GL_CURRENT_FOG_COORD, GL_CURRENT_FOG_COORDINATE) \
  CONST(GL_FOG_COORD_ARRAY_TYPE, GL_FOG_COORDINATE_ARRAY_TYPE) \
  CONST(GL_FOG_COORD_ARRAY_STRIDE, GL_FOG_COORDINATE_ARRAY_STRIDE) \
  CONST(GL_FOG_COORD_ARRAY_POINTER, GL_FOG_COORDINATE_ARRAY_POINTER) \
  CONST(GL_FOG_COORD_ARRAY, GL_FOG_COORDINATE_ARRAY) \
  CONST(GL_FOG_COORD_ARRAY_BUFFER_BINDING, GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING) \
  CONST(GL_SRC0_RGB, GL_SOURCE0_RGB) \
  CONST(GL_SRC1_RGB, GL_SOURCE1_RGB) \
  CONST(GL_SRC2_RGB, GL_SOURCE2_RGB) \
  CONST(GL_SRC0_ALPHA, GL_SOURCE0_ALPHA) \
  CONST(GL_SRC1_ALPHA, GL_SOURCE1_ALPHA) \
  CONST(GL_SRC2_ALPHA, GL_SOURCE2_ALPHA) \
  END()
#else
#define EXTENSION_GL_VERSION_1_5(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_VERSION_2_0
#define GL_VERSION_2_0 1
#define EXTENSION_GL_VERSION_2_0(NAME, FUNC, CONST, END) \
  NAME(GL_VERSION_2_0) \
  FUNC(void, glBlendEquationSeparate, GLBLENDEQUATIONSEPARATE, (GLenum modeRGB, GLenum modeAlpha)) \
  FUNC(void, glDrawBuffers, GLDRAWBUFFERS, (GLsizei n, const GLenum * bufs)) \
  FUNC(void, glStencilOpSeparate, GLSTENCILOPSEPARATE, (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)) \
  FUNC(void, glStencilFuncSeparate, GLSTENCILFUNCSEPARATE, (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)) \
  FUNC(void, glStencilMaskSeparate, GLSTENCILMASKSEPARATE, (GLenum face, GLuint mask)) \
  FUNC(void, glAttachShader, GLATTACHSHADER, (GLuint program, GLuint shader)) \
  FUNC(void, glBindAttribLocation, GLBINDATTRIBLOCATION, (GLuint program, GLuint index, const GLchar * name)) \
  FUNC(void, glCompileShader, GLCOMPILESHADER, (GLuint shader)) \
  FUNC(GLuint, glCreateProgram, GLCREATEPROGRAM, ()) \
  FUNC(GLuint, glCreateShader, GLCREATESHADER, (GLenum type)) \
  FUNC(void, glDeleteProgram, GLDELETEPROGRAM, (GLuint program)) \
  FUNC(void, glDeleteShader, GLDELETESHADER, (GLuint shader)) \
  FUNC(void, glDetachShader, GLDETACHSHADER, (GLuint program, GLuint shader)) \
  FUNC(void, glDisableVertexAttribArray, GLDISABLEVERTEXATTRIBARRAY, (GLuint index)) \
  FUNC(void, glEnableVertexAttribArray, GLENABLEVERTEXATTRIBARRAY, (GLuint index)) \
  FUNC(void, glGetActiveAttrib, GLGETACTIVEATTRIB, (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)) \
  FUNC(void, glGetActiveUniform, GLGETACTIVEUNIFORM, (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)) \
  FUNC(void, glGetAttachedShaders, GLGETATTACHEDSHADERS, (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * obj)) \
  FUNC(GLint, glGetAttribLocation, GLGETATTRIBLOCATION, (GLuint program, const GLchar * name)) \
  FUNC(void, glGetProgramiv, GLGETPROGRAMIV, (GLuint program, GLenum pname, GLint * params)) \
  FUNC(void, glGetProgramInfoLog, GLGETPROGRAMINFOLOG, (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog)) \
  FUNC(void, glGetShaderiv, GLGETSHADERIV, (GLuint shader, GLenum pname, GLint * params)) \
  FUNC(void, glGetShaderInfoLog, GLGETSHADERINFOLOG, (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog)) \
  FUNC(void, glGetShaderSource, GLGETSHADERSOURCE, (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source)) \
  FUNC(GLint, glGetUniformLocation, GLGETUNIFORMLOCATION, (GLuint program, const GLchar * name)) \
  FUNC(void, glGetUniformfv, GLGETUNIFORMFV, (GLuint program, GLint location, GLfloat * params)) \
  FUNC(void, glGetUniformiv, GLGETUNIFORMIV, (GLuint program, GLint location, GLint * params)) \
  FUNC(void, glGetVertexAttribdv, GLGETVERTEXATTRIBDV, (GLuint index, GLenum pname, GLdouble * params)) \
  FUNC(void, glGetVertexAttribfv, GLGETVERTEXATTRIBFV, (GLuint index, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetVertexAttribiv, GLGETVERTEXATTRIBIV, (GLuint index, GLenum pname, GLint * params)) \
  FUNC(void, glGetVertexAttribPointerv, GLGETVERTEXATTRIBPOINTERV, (GLuint index, GLenum pname, GLvoid* * pointer)) \
  FUNC(GLboolean, glIsProgram, GLISPROGRAM, (GLuint program)) \
  FUNC(GLboolean, glIsShader, GLISSHADER, (GLuint shader)) \
  FUNC(void, glLinkProgram, GLLINKPROGRAM, (GLuint program)) \
  FUNC(void, glShaderSource, GLSHADERSOURCE, (GLuint shader, GLsizei count, const GLchar* * string, const GLint * length)) \
  FUNC(void, glUseProgram, GLUSEPROGRAM, (GLuint program)) \
  FUNC(void, glUniform1f, GLUNIFORM1F, (GLint location, GLfloat v0)) \
  FUNC(void, glUniform2f, GLUNIFORM2F, (GLint location, GLfloat v0, GLfloat v1)) \
  FUNC(void, glUniform3f, GLUNIFORM3F, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) \
  FUNC(void, glUniform4f, GLUNIFORM4F, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) \
  FUNC(void, glUniform1i, GLUNIFORM1I, (GLint location, GLint v0)) \
  FUNC(void, glUniform2i, GLUNIFORM2I, (GLint location, GLint v0, GLint v1)) \
  FUNC(void, glUniform3i, GLUNIFORM3I, (GLint location, GLint v0, GLint v1, GLint v2)) \
  FUNC(void, glUniform4i, GLUNIFORM4I, (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) \
  FUNC(void, glUniform1fv, GLUNIFORM1FV, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform2fv, GLUNIFORM2FV, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform3fv, GLUNIFORM3FV, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform4fv, GLUNIFORM4FV, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform1iv, GLUNIFORM1IV, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniform2iv, GLUNIFORM2IV, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniform3iv, GLUNIFORM3IV, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniform4iv, GLUNIFORM4IV, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniformMatrix2fv, GLUNIFORMMATRIX2FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix3fv, GLUNIFORMMATRIX3FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix4fv, GLUNIFORMMATRIX4FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glValidateProgram, GLVALIDATEPROGRAM, (GLuint program)) \
  FUNC(void, glVertexAttrib1d, GLVERTEXATTRIB1D, (GLuint index, GLdouble x)) \
  FUNC(void, glVertexAttrib1dv, GLVERTEXATTRIB1DV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib1f, GLVERTEXATTRIB1F, (GLuint index, GLfloat x)) \
  FUNC(void, glVertexAttrib1fv, GLVERTEXATTRIB1FV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib1s, GLVERTEXATTRIB1S, (GLuint index, GLshort x)) \
  FUNC(void, glVertexAttrib1sv, GLVERTEXATTRIB1SV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib2d, GLVERTEXATTRIB2D, (GLuint index, GLdouble x, GLdouble y)) \
  FUNC(void, glVertexAttrib2dv, GLVERTEXATTRIB2DV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib2f, GLVERTEXATTRIB2F, (GLuint index, GLfloat x, GLfloat y)) \
  FUNC(void, glVertexAttrib2fv, GLVERTEXATTRIB2FV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib2s, GLVERTEXATTRIB2S, (GLuint index, GLshort x, GLshort y)) \
  FUNC(void, glVertexAttrib2sv, GLVERTEXATTRIB2SV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib3d, GLVERTEXATTRIB3D, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
  FUNC(void, glVertexAttrib3dv, GLVERTEXATTRIB3DV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib3f, GLVERTEXATTRIB3F, (GLuint index, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glVertexAttrib3fv, GLVERTEXATTRIB3FV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib3s, GLVERTEXATTRIB3S, (GLuint index, GLshort x, GLshort y, GLshort z)) \
  FUNC(void, glVertexAttrib3sv, GLVERTEXATTRIB3SV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4Nbv, GLVERTEXATTRIB4NBV, (GLuint index, const GLbyte * v)) \
  FUNC(void, glVertexAttrib4Niv, GLVERTEXATTRIB4NIV, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttrib4Nsv, GLVERTEXATTRIB4NSV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4Nub, GLVERTEXATTRIB4NUB, (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)) \
  FUNC(void, glVertexAttrib4Nubv, GLVERTEXATTRIB4NUBV, (GLuint index, const GLubyte * v)) \
  FUNC(void, glVertexAttrib4Nuiv, GLVERTEXATTRIB4NUIV, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttrib4Nusv, GLVERTEXATTRIB4NUSV, (GLuint index, const GLushort * v)) \
  FUNC(void, glVertexAttrib4bv, GLVERTEXATTRIB4BV, (GLuint index, const GLbyte * v)) \
  FUNC(void, glVertexAttrib4d, GLVERTEXATTRIB4D, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glVertexAttrib4dv, GLVERTEXATTRIB4DV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib4f, GLVERTEXATTRIB4F, (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glVertexAttrib4fv, GLVERTEXATTRIB4FV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib4iv, GLVERTEXATTRIB4IV, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttrib4s, GLVERTEXATTRIB4S, (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)) \
  FUNC(void, glVertexAttrib4sv, GLVERTEXATTRIB4SV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4ubv, GLVERTEXATTRIB4UBV, (GLuint index, const GLubyte * v)) \
  FUNC(void, glVertexAttrib4uiv, GLVERTEXATTRIB4UIV, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttrib4usv, GLVERTEXATTRIB4USV, (GLuint index, const GLushort * v)) \
  FUNC(void, glVertexAttribPointer, GLVERTEXATTRIBPOINTER, (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)) \
  CONST(GL_BLEND_EQUATION_RGB, GL_BLEND_EQUATION) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_ENABLED, 0x8622) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_SIZE, 0x8623) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_STRIDE, 0x8624) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_TYPE, 0x8625) \
  CONST(GL_CURRENT_VERTEX_ATTRIB, 0x8626) \
  CONST(GL_VERTEX_PROGRAM_POINT_SIZE, 0x8642) \
  CONST(GL_VERTEX_PROGRAM_TWO_SIDE, 0x8643) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_POINTER, 0x8645) \
  CONST(GL_STENCIL_BACK_FUNC, 0x8800) \
  CONST(GL_STENCIL_BACK_FAIL, 0x8801) \
  CONST(GL_STENCIL_BACK_PASS_DEPTH_FAIL, 0x8802) \
  CONST(GL_STENCIL_BACK_PASS_DEPTH_PASS, 0x8803) \
  CONST(GL_MAX_DRAW_BUFFERS, 0x8824) \
  CONST(GL_DRAW_BUFFER0, 0x8825) \
  CONST(GL_DRAW_BUFFER1, 0x8826) \
  CONST(GL_DRAW_BUFFER2, 0x8827) \
  CONST(GL_DRAW_BUFFER3, 0x8828) \
  CONST(GL_DRAW_BUFFER4, 0x8829) \
  CONST(GL_DRAW_BUFFER5, 0x882A) \
  CONST(GL_DRAW_BUFFER6, 0x882B) \
  CONST(GL_DRAW_BUFFER7, 0x882C) \
  CONST(GL_DRAW_BUFFER8, 0x882D) \
  CONST(GL_DRAW_BUFFER9, 0x882E) \
  CONST(GL_DRAW_BUFFER10, 0x882F) \
  CONST(GL_DRAW_BUFFER11, 0x8830) \
  CONST(GL_DRAW_BUFFER12, 0x8831) \
  CONST(GL_DRAW_BUFFER13, 0x8832) \
  CONST(GL_DRAW_BUFFER14, 0x8833) \
  CONST(GL_DRAW_BUFFER15, 0x8834) \
  CONST(GL_BLEND_EQUATION_ALPHA, 0x883D) \
  CONST(GL_POINT_SPRITE, 0x8861) \
  CONST(GL_COORD_REPLACE, 0x8862) \
  CONST(GL_MAX_VERTEX_ATTRIBS, 0x8869) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, 0x886A) \
  CONST(GL_MAX_TEXTURE_COORDS, 0x8871) \
  CONST(GL_MAX_TEXTURE_IMAGE_UNITS, 0x8872) \
  CONST(GL_FRAGMENT_SHADER, 0x8B30) \
  CONST(GL_VERTEX_SHADER, 0x8B31) \
  CONST(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, 0x8B49) \
  CONST(GL_MAX_VERTEX_UNIFORM_COMPONENTS, 0x8B4A) \
  CONST(GL_MAX_VARYING_FLOATS, 0x8B4B) \
  CONST(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, 0x8B4C) \
  CONST(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, 0x8B4D) \
  CONST(GL_SHADER_TYPE, 0x8B4F) \
  CONST(GL_FLOAT_VEC2, 0x8B50) \
  CONST(GL_FLOAT_VEC3, 0x8B51) \
  CONST(GL_FLOAT_VEC4, 0x8B52) \
  CONST(GL_INT_VEC2, 0x8B53) \
  CONST(GL_INT_VEC3, 0x8B54) \
  CONST(GL_INT_VEC4, 0x8B55) \
  CONST(GL_BOOL, 0x8B56) \
  CONST(GL_BOOL_VEC2, 0x8B57) \
  CONST(GL_BOOL_VEC3, 0x8B58) \
  CONST(GL_BOOL_VEC4, 0x8B59) \
  CONST(GL_FLOAT_MAT2, 0x8B5A) \
  CONST(GL_FLOAT_MAT3, 0x8B5B) \
  CONST(GL_FLOAT_MAT4, 0x8B5C) \
  CONST(GL_SAMPLER_1D, 0x8B5D) \
  CONST(GL_SAMPLER_2D, 0x8B5E) \
  CONST(GL_SAMPLER_3D, 0x8B5F) \
  CONST(GL_SAMPLER_CUBE, 0x8B60) \
  CONST(GL_SAMPLER_1D_SHADOW, 0x8B61) \
  CONST(GL_SAMPLER_2D_SHADOW, 0x8B62) \
  CONST(GL_DELETE_STATUS, 0x8B80) \
  CONST(GL_COMPILE_STATUS, 0x8B81) \
  CONST(GL_LINK_STATUS, 0x8B82) \
  CONST(GL_VALIDATE_STATUS, 0x8B83) \
  CONST(GL_INFO_LOG_LENGTH, 0x8B84) \
  CONST(GL_ATTACHED_SHADERS, 0x8B85) \
  CONST(GL_ACTIVE_UNIFORMS, 0x8B86) \
  CONST(GL_ACTIVE_UNIFORM_MAX_LENGTH, 0x8B87) \
  CONST(GL_SHADER_SOURCE_LENGTH, 0x8B88) \
  CONST(GL_ACTIVE_ATTRIBUTES, 0x8B89) \
  CONST(GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, 0x8B8A) \
  CONST(GL_FRAGMENT_SHADER_DERIVATIVE_HINT, 0x8B8B) \
  CONST(GL_SHADING_LANGUAGE_VERSION, 0x8B8C) \
  CONST(GL_CURRENT_PROGRAM, 0x8B8D) \
  CONST(GL_POINT_SPRITE_COORD_ORIGIN, 0x8CA0) \
  CONST(GL_LOWER_LEFT, 0x8CA1) \
  CONST(GL_UPPER_LEFT, 0x8CA2) \
  CONST(GL_STENCIL_BACK_REF, 0x8CA3) \
  CONST(GL_STENCIL_BACK_VALUE_MASK, 0x8CA4) \
  CONST(GL_STENCIL_BACK_WRITEMASK, 0x8CA5) \
  END()
#else
#define EXTENSION_GL_VERSION_2_0(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_VERSION_2_1
#define GL_VERSION_2_1 1
#define EXTENSION_GL_VERSION_2_1(NAME, FUNC, CONST, END) \
  NAME(GL_VERSION_2_1) \
  FUNC(void, glUniformMatrix2x3fv, GLUNIFORMMATRIX2X3FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix3x2fv, GLUNIFORMMATRIX3X2FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix2x4fv, GLUNIFORMMATRIX2X4FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix4x2fv, GLUNIFORMMATRIX4X2FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix3x4fv, GLUNIFORMMATRIX3X4FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix4x3fv, GLUNIFORMMATRIX4X3FV, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  CONST(GL_PIXEL_PACK_BUFFER, 0x88EB) \
  CONST(GL_PIXEL_UNPACK_BUFFER, 0x88EC) \
  CONST(GL_PIXEL_PACK_BUFFER_BINDING, 0x88ED) \
  CONST(GL_PIXEL_UNPACK_BUFFER_BINDING, 0x88EF) \
  CONST(GL_SRGB, 0x8C40) \
  CONST(GL_SRGB8, 0x8C41) \
  CONST(GL_SRGB_ALPHA, 0x8C42) \
  CONST(GL_SRGB8_ALPHA8, 0x8C43) \
  CONST(GL_SLUMINANCE_ALPHA, 0x8C44) \
  CONST(GL_SLUMINANCE8_ALPHA8, 0x8C45) \
  CONST(GL_SLUMINANCE, 0x8C46) \
  CONST(GL_SLUMINANCE8, 0x8C47) \
  CONST(GL_COMPRESSED_SRGB, 0x8C48) \
  CONST(GL_COMPRESSED_SRGB_ALPHA, 0x8C49) \
  CONST(GL_COMPRESSED_SLUMINANCE, 0x8C4A) \
  CONST(GL_COMPRESSED_SLUMINANCE_ALPHA, 0x8C4B) \
  CONST(GL_FLOAT_MAT2x3, 0x8B65) \
  CONST(GL_FLOAT_MAT2x4, 0x8B66) \
  CONST(GL_FLOAT_MAT3x2, 0x8B67) \
  CONST(GL_FLOAT_MAT3x4, 0x8B68) \
  CONST(GL_FLOAT_MAT4x2, 0x8B69) \
  CONST(GL_FLOAT_MAT4x3, 0x8B6A) \
  CONST(GL_CURRENT_RASTER_SECONDARY_COLOR, 0x845F) \
  END()
#else
#define EXTENSION_GL_VERSION_2_1(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_multitexture
#define GL_ARB_multitexture 1
#define EXTENSION_GL_ARB_multitexture(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_multitexture) \
  FUNC(void, glActiveTextureARB, GLACTIVETEXTUREARB, (GLenum texture)) \
  FUNC(void, glClientActiveTextureARB, GLCLIENTACTIVETEXTUREARB, (GLenum texture)) \
  FUNC(void, glMultiTexCoord1dARB, GLMULTITEXCOORD1DARB, (GLenum target, GLdouble s)) \
  FUNC(void, glMultiTexCoord1dvARB, GLMULTITEXCOORD1DVARB, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord1fARB, GLMULTITEXCOORD1FARB, (GLenum target, GLfloat s)) \
  FUNC(void, glMultiTexCoord1fvARB, GLMULTITEXCOORD1FVARB, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord1iARB, GLMULTITEXCOORD1IARB, (GLenum target, GLint s)) \
  FUNC(void, glMultiTexCoord1ivARB, GLMULTITEXCOORD1IVARB, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord1sARB, GLMULTITEXCOORD1SARB, (GLenum target, GLshort s)) \
  FUNC(void, glMultiTexCoord1svARB, GLMULTITEXCOORD1SVARB, (GLenum target, const GLshort * v)) \
  FUNC(void, glMultiTexCoord2dARB, GLMULTITEXCOORD2DARB, (GLenum target, GLdouble s, GLdouble t)) \
  FUNC(void, glMultiTexCoord2dvARB, GLMULTITEXCOORD2DVARB, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord2fARB, GLMULTITEXCOORD2FARB, (GLenum target, GLfloat s, GLfloat t)) \
  FUNC(void, glMultiTexCoord2fvARB, GLMULTITEXCOORD2FVARB, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord2iARB, GLMULTITEXCOORD2IARB, (GLenum target, GLint s, GLint t)) \
  FUNC(void, glMultiTexCoord2ivARB, GLMULTITEXCOORD2IVARB, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord2sARB, GLMULTITEXCOORD2SARB, (GLenum target, GLshort s, GLshort t)) \
  FUNC(void, glMultiTexCoord2svARB, GLMULTITEXCOORD2SVARB, (GLenum target, const GLshort * v)) \
  FUNC(void, glMultiTexCoord3dARB, GLMULTITEXCOORD3DARB, (GLenum target, GLdouble s, GLdouble t, GLdouble r)) \
  FUNC(void, glMultiTexCoord3dvARB, GLMULTITEXCOORD3DVARB, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord3fARB, GLMULTITEXCOORD3FARB, (GLenum target, GLfloat s, GLfloat t, GLfloat r)) \
  FUNC(void, glMultiTexCoord3fvARB, GLMULTITEXCOORD3FVARB, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord3iARB, GLMULTITEXCOORD3IARB, (GLenum target, GLint s, GLint t, GLint r)) \
  FUNC(void, glMultiTexCoord3ivARB, GLMULTITEXCOORD3IVARB, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord3sARB, GLMULTITEXCOORD3SARB, (GLenum target, GLshort s, GLshort t, GLshort r)) \
  FUNC(void, glMultiTexCoord3svARB, GLMULTITEXCOORD3SVARB, (GLenum target, const GLshort * v)) \
  FUNC(void, glMultiTexCoord4dARB, GLMULTITEXCOORD4DARB, (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)) \
  FUNC(void, glMultiTexCoord4dvARB, GLMULTITEXCOORD4DVARB, (GLenum target, const GLdouble * v)) \
  FUNC(void, glMultiTexCoord4fARB, GLMULTITEXCOORD4FARB, (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)) \
  FUNC(void, glMultiTexCoord4fvARB, GLMULTITEXCOORD4FVARB, (GLenum target, const GLfloat * v)) \
  FUNC(void, glMultiTexCoord4iARB, GLMULTITEXCOORD4IARB, (GLenum target, GLint s, GLint t, GLint r, GLint q)) \
  FUNC(void, glMultiTexCoord4ivARB, GLMULTITEXCOORD4IVARB, (GLenum target, const GLint * v)) \
  FUNC(void, glMultiTexCoord4sARB, GLMULTITEXCOORD4SARB, (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)) \
  FUNC(void, glMultiTexCoord4svARB, GLMULTITEXCOORD4SVARB, (GLenum target, const GLshort * v)) \
  CONST(GL_TEXTURE0_ARB, 0x84C0) \
  CONST(GL_TEXTURE1_ARB, 0x84C1) \
  CONST(GL_TEXTURE2_ARB, 0x84C2) \
  CONST(GL_TEXTURE3_ARB, 0x84C3) \
  CONST(GL_TEXTURE4_ARB, 0x84C4) \
  CONST(GL_TEXTURE5_ARB, 0x84C5) \
  CONST(GL_TEXTURE6_ARB, 0x84C6) \
  CONST(GL_TEXTURE7_ARB, 0x84C7) \
  CONST(GL_TEXTURE8_ARB, 0x84C8) \
  CONST(GL_TEXTURE9_ARB, 0x84C9) \
  CONST(GL_TEXTURE10_ARB, 0x84CA) \
  CONST(GL_TEXTURE11_ARB, 0x84CB) \
  CONST(GL_TEXTURE12_ARB, 0x84CC) \
  CONST(GL_TEXTURE13_ARB, 0x84CD) \
  CONST(GL_TEXTURE14_ARB, 0x84CE) \
  CONST(GL_TEXTURE15_ARB, 0x84CF) \
  CONST(GL_TEXTURE16_ARB, 0x84D0) \
  CONST(GL_TEXTURE17_ARB, 0x84D1) \
  CONST(GL_TEXTURE18_ARB, 0x84D2) \
  CONST(GL_TEXTURE19_ARB, 0x84D3) \
  CONST(GL_TEXTURE20_ARB, 0x84D4) \
  CONST(GL_TEXTURE21_ARB, 0x84D5) \
  CONST(GL_TEXTURE22_ARB, 0x84D6) \
  CONST(GL_TEXTURE23_ARB, 0x84D7) \
  CONST(GL_TEXTURE24_ARB, 0x84D8) \
  CONST(GL_TEXTURE25_ARB, 0x84D9) \
  CONST(GL_TEXTURE26_ARB, 0x84DA) \
  CONST(GL_TEXTURE27_ARB, 0x84DB) \
  CONST(GL_TEXTURE28_ARB, 0x84DC) \
  CONST(GL_TEXTURE29_ARB, 0x84DD) \
  CONST(GL_TEXTURE30_ARB, 0x84DE) \
  CONST(GL_TEXTURE31_ARB, 0x84DF) \
  CONST(GL_ACTIVE_TEXTURE_ARB, 0x84E0) \
  CONST(GL_CLIENT_ACTIVE_TEXTURE_ARB, 0x84E1) \
  CONST(GL_MAX_TEXTURE_UNITS_ARB, 0x84E2) \
  END()
#else
#define EXTENSION_GL_ARB_multitexture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_transpose_matrix
#define GL_ARB_transpose_matrix 1
#define EXTENSION_GL_ARB_transpose_matrix(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_transpose_matrix) \
  FUNC(void, glLoadTransposeMatrixfARB, GLLOADTRANSPOSEMATRIXFARB, (const GLfloat * m)) \
  FUNC(void, glLoadTransposeMatrixdARB, GLLOADTRANSPOSEMATRIXDARB, (const GLdouble * m)) \
  FUNC(void, glMultTransposeMatrixfARB, GLMULTTRANSPOSEMATRIXFARB, (const GLfloat * m)) \
  FUNC(void, glMultTransposeMatrixdARB, GLMULTTRANSPOSEMATRIXDARB, (const GLdouble * m)) \
  CONST(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB, 0x84E3) \
  CONST(GL_TRANSPOSE_PROJECTION_MATRIX_ARB, 0x84E4) \
  CONST(GL_TRANSPOSE_TEXTURE_MATRIX_ARB, 0x84E5) \
  CONST(GL_TRANSPOSE_COLOR_MATRIX_ARB, 0x84E6) \
  END()
#else
#define EXTENSION_GL_ARB_transpose_matrix(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_multisample
#define GL_ARB_multisample 1
#define EXTENSION_GL_ARB_multisample(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_multisample) \
  FUNC(void, glSampleCoverageARB, GLSAMPLECOVERAGEARB, (GLclampf value, GLboolean invert)) \
  CONST(GL_MULTISAMPLE_ARB, 0x809D) \
  CONST(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB, 0x809E) \
  CONST(GL_SAMPLE_ALPHA_TO_ONE_ARB, 0x809F) \
  CONST(GL_SAMPLE_COVERAGE_ARB, 0x80A0) \
  CONST(GL_SAMPLE_BUFFERS_ARB, 0x80A8) \
  CONST(GL_SAMPLES_ARB, 0x80A9) \
  CONST(GL_SAMPLE_COVERAGE_VALUE_ARB, 0x80AA) \
  CONST(GL_SAMPLE_COVERAGE_INVERT_ARB, 0x80AB) \
  CONST(GL_MULTISAMPLE_BIT_ARB, 0x20000000) \
  END()
#else
#define EXTENSION_GL_ARB_multisample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_env_add
#define GL_ARB_texture_env_add 1
#define EXTENSION_GL_ARB_texture_env_add(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_env_add) \
  END()
#else
#define EXTENSION_GL_ARB_texture_env_add(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_cube_map
#define GL_ARB_texture_cube_map 1
#define EXTENSION_GL_ARB_texture_cube_map(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_cube_map) \
  CONST(GL_NORMAL_MAP_ARB, 0x8511) \
  CONST(GL_REFLECTION_MAP_ARB, 0x8512) \
  CONST(GL_TEXTURE_CUBE_MAP_ARB, 0x8513) \
  CONST(GL_TEXTURE_BINDING_CUBE_MAP_ARB, 0x8514) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0x8515) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0x8516) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0x8517) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0x8518) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0x8519) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0x851A) \
  CONST(GL_PROXY_TEXTURE_CUBE_MAP_ARB, 0x851B) \
  CONST(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, 0x851C) \
  END()
#else
#define EXTENSION_GL_ARB_texture_cube_map(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_compression
#define GL_ARB_texture_compression 1
#define EXTENSION_GL_ARB_texture_compression(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_compression) \
  FUNC(void, glCompressedTexImage3DARB, GLCOMPRESSEDTEXIMAGE3DARB, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexImage2DARB, GLCOMPRESSEDTEXIMAGE2DARB, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexImage1DARB, GLCOMPRESSEDTEXIMAGE1DARB, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexSubImage3DARB, GLCOMPRESSEDTEXSUBIMAGE3DARB, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexSubImage2DARB, GLCOMPRESSEDTEXSUBIMAGE2DARB, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glCompressedTexSubImage1DARB, GLCOMPRESSEDTEXSUBIMAGE1DARB, (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)) \
  FUNC(void, glGetCompressedTexImageARB, GLGETCOMPRESSEDTEXIMAGEARB, (GLenum target, GLint level, GLvoid * img)) \
  CONST(GL_COMPRESSED_ALPHA_ARB, 0x84E9) \
  CONST(GL_COMPRESSED_LUMINANCE_ARB, 0x84EA) \
  CONST(GL_COMPRESSED_LUMINANCE_ALPHA_ARB, 0x84EB) \
  CONST(GL_COMPRESSED_INTENSITY_ARB, 0x84EC) \
  CONST(GL_COMPRESSED_RGB_ARB, 0x84ED) \
  CONST(GL_COMPRESSED_RGBA_ARB, 0x84EE) \
  CONST(GL_TEXTURE_COMPRESSION_HINT_ARB, 0x84EF) \
  CONST(GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, 0x86A0) \
  CONST(GL_TEXTURE_COMPRESSED_ARB, 0x86A1) \
  CONST(GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, 0x86A2) \
  CONST(GL_COMPRESSED_TEXTURE_FORMATS_ARB, 0x86A3) \
  END()
#else
#define EXTENSION_GL_ARB_texture_compression(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_border_clamp
#define GL_ARB_texture_border_clamp 1
#define EXTENSION_GL_ARB_texture_border_clamp(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_border_clamp) \
  CONST(GL_CLAMP_TO_BORDER_ARB, 0x812D) \
  END()
#else
#define EXTENSION_GL_ARB_texture_border_clamp(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_point_parameters
#define GL_ARB_point_parameters 1
#define EXTENSION_GL_ARB_point_parameters(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_point_parameters) \
  FUNC(void, glPointParameterfARB, GLPOINTPARAMETERFARB, (GLenum pname, GLfloat param)) \
  FUNC(void, glPointParameterfvARB, GLPOINTPARAMETERFVARB, (GLenum pname, const GLfloat * params)) \
  CONST(GL_POINT_SIZE_MIN_ARB, 0x8126) \
  CONST(GL_POINT_SIZE_MAX_ARB, 0x8127) \
  CONST(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0x8128) \
  CONST(GL_POINT_DISTANCE_ATTENUATION_ARB, 0x8129) \
  END()
#else
#define EXTENSION_GL_ARB_point_parameters(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_vertex_blend
#define GL_ARB_vertex_blend 1
#define EXTENSION_GL_ARB_vertex_blend(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_vertex_blend) \
  FUNC(void, glWeightbvARB, GLWEIGHTBVARB, (GLint size, const GLbyte * weights)) \
  FUNC(void, glWeightsvARB, GLWEIGHTSVARB, (GLint size, const GLshort * weights)) \
  FUNC(void, glWeightivARB, GLWEIGHTIVARB, (GLint size, const GLint * weights)) \
  FUNC(void, glWeightfvARB, GLWEIGHTFVARB, (GLint size, const GLfloat * weights)) \
  FUNC(void, glWeightdvARB, GLWEIGHTDVARB, (GLint size, const GLdouble * weights)) \
  FUNC(void, glWeightubvARB, GLWEIGHTUBVARB, (GLint size, const GLubyte * weights)) \
  FUNC(void, glWeightusvARB, GLWEIGHTUSVARB, (GLint size, const GLushort * weights)) \
  FUNC(void, glWeightuivARB, GLWEIGHTUIVARB, (GLint size, const GLuint * weights)) \
  FUNC(void, glWeightPointerARB, GLWEIGHTPOINTERARB, (GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)) \
  FUNC(void, glVertexBlendARB, GLVERTEXBLENDARB, (GLint count)) \
  CONST(GL_MAX_VERTEX_UNITS_ARB, 0x86A4) \
  CONST(GL_ACTIVE_VERTEX_UNITS_ARB, 0x86A5) \
  CONST(GL_WEIGHT_SUM_UNITY_ARB, 0x86A6) \
  CONST(GL_VERTEX_BLEND_ARB, 0x86A7) \
  CONST(GL_CURRENT_WEIGHT_ARB, 0x86A8) \
  CONST(GL_WEIGHT_ARRAY_TYPE_ARB, 0x86A9) \
  CONST(GL_WEIGHT_ARRAY_STRIDE_ARB, 0x86AA) \
  CONST(GL_WEIGHT_ARRAY_SIZE_ARB, 0x86AB) \
  CONST(GL_WEIGHT_ARRAY_POINTER_ARB, 0x86AC) \
  CONST(GL_WEIGHT_ARRAY_ARB, 0x86AD) \
  CONST(GL_MODELVIEW0_ARB, 0x1700) \
  CONST(GL_MODELVIEW1_ARB, 0x850A) \
  CONST(GL_MODELVIEW2_ARB, 0x8722) \
  CONST(GL_MODELVIEW3_ARB, 0x8723) \
  CONST(GL_MODELVIEW4_ARB, 0x8724) \
  CONST(GL_MODELVIEW5_ARB, 0x8725) \
  CONST(GL_MODELVIEW6_ARB, 0x8726) \
  CONST(GL_MODELVIEW7_ARB, 0x8727) \
  CONST(GL_MODELVIEW8_ARB, 0x8728) \
  CONST(GL_MODELVIEW9_ARB, 0x8729) \
  CONST(GL_MODELVIEW10_ARB, 0x872A) \
  CONST(GL_MODELVIEW11_ARB, 0x872B) \
  CONST(GL_MODELVIEW12_ARB, 0x872C) \
  CONST(GL_MODELVIEW13_ARB, 0x872D) \
  CONST(GL_MODELVIEW14_ARB, 0x872E) \
  CONST(GL_MODELVIEW15_ARB, 0x872F) \
  CONST(GL_MODELVIEW16_ARB, 0x8730) \
  CONST(GL_MODELVIEW17_ARB, 0x8731) \
  CONST(GL_MODELVIEW18_ARB, 0x8732) \
  CONST(GL_MODELVIEW19_ARB, 0x8733) \
  CONST(GL_MODELVIEW20_ARB, 0x8734) \
  CONST(GL_MODELVIEW21_ARB, 0x8735) \
  CONST(GL_MODELVIEW22_ARB, 0x8736) \
  CONST(GL_MODELVIEW23_ARB, 0x8737) \
  CONST(GL_MODELVIEW24_ARB, 0x8738) \
  CONST(GL_MODELVIEW25_ARB, 0x8739) \
  CONST(GL_MODELVIEW26_ARB, 0x873A) \
  CONST(GL_MODELVIEW27_ARB, 0x873B) \
  CONST(GL_MODELVIEW28_ARB, 0x873C) \
  CONST(GL_MODELVIEW29_ARB, 0x873D) \
  CONST(GL_MODELVIEW30_ARB, 0x873E) \
  CONST(GL_MODELVIEW31_ARB, 0x873F) \
  END()
#else
#define EXTENSION_GL_ARB_vertex_blend(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_matrix_palette
#define GL_ARB_matrix_palette 1
#define EXTENSION_GL_ARB_matrix_palette(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_matrix_palette) \
  FUNC(void, glCurrentPaletteMatrixARB, GLCURRENTPALETTEMATRIXARB, (GLint index)) \
  FUNC(void, glMatrixIndexubvARB, GLMATRIXINDEXUBVARB, (GLint size, const GLubyte * indices)) \
  FUNC(void, glMatrixIndexusvARB, GLMATRIXINDEXUSVARB, (GLint size, const GLushort * indices)) \
  FUNC(void, glMatrixIndexuivARB, GLMATRIXINDEXUIVARB, (GLint size, const GLuint * indices)) \
  FUNC(void, glMatrixIndexPointerARB, GLMATRIXINDEXPOINTERARB, (GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)) \
  CONST(GL_MATRIX_PALETTE_ARB, 0x8840) \
  CONST(GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB, 0x8841) \
  CONST(GL_MAX_PALETTE_MATRICES_ARB, 0x8842) \
  CONST(GL_CURRENT_PALETTE_MATRIX_ARB, 0x8843) \
  CONST(GL_MATRIX_INDEX_ARRAY_ARB, 0x8844) \
  CONST(GL_CURRENT_MATRIX_INDEX_ARB, 0x8845) \
  CONST(GL_MATRIX_INDEX_ARRAY_SIZE_ARB, 0x8846) \
  CONST(GL_MATRIX_INDEX_ARRAY_TYPE_ARB, 0x8847) \
  CONST(GL_MATRIX_INDEX_ARRAY_STRIDE_ARB, 0x8848) \
  CONST(GL_MATRIX_INDEX_ARRAY_POINTER_ARB, 0x8849) \
  END()
#else
#define EXTENSION_GL_ARB_matrix_palette(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_env_combine
#define GL_ARB_texture_env_combine 1
#define EXTENSION_GL_ARB_texture_env_combine(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_env_combine) \
  CONST(GL_COMBINE_ARB, 0x8570) \
  CONST(GL_COMBINE_RGB_ARB, 0x8571) \
  CONST(GL_COMBINE_ALPHA_ARB, 0x8572) \
  CONST(GL_SOURCE0_RGB_ARB, 0x8580) \
  CONST(GL_SOURCE1_RGB_ARB, 0x8581) \
  CONST(GL_SOURCE2_RGB_ARB, 0x8582) \
  CONST(GL_SOURCE0_ALPHA_ARB, 0x8588) \
  CONST(GL_SOURCE1_ALPHA_ARB, 0x8589) \
  CONST(GL_SOURCE2_ALPHA_ARB, 0x858A) \
  CONST(GL_OPERAND0_RGB_ARB, 0x8590) \
  CONST(GL_OPERAND1_RGB_ARB, 0x8591) \
  CONST(GL_OPERAND2_RGB_ARB, 0x8592) \
  CONST(GL_OPERAND0_ALPHA_ARB, 0x8598) \
  CONST(GL_OPERAND1_ALPHA_ARB, 0x8599) \
  CONST(GL_OPERAND2_ALPHA_ARB, 0x859A) \
  CONST(GL_RGB_SCALE_ARB, 0x8573) \
  CONST(GL_ADD_SIGNED_ARB, 0x8574) \
  CONST(GL_INTERPOLATE_ARB, 0x8575) \
  CONST(GL_SUBTRACT_ARB, 0x84E7) \
  CONST(GL_CONSTANT_ARB, 0x8576) \
  CONST(GL_PRIMARY_COLOR_ARB, 0x8577) \
  CONST(GL_PREVIOUS_ARB, 0x8578) \
  END()
#else
#define EXTENSION_GL_ARB_texture_env_combine(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_env_crossbar
#define GL_ARB_texture_env_crossbar 1
#define EXTENSION_GL_ARB_texture_env_crossbar(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_env_crossbar) \
  END()
#else
#define EXTENSION_GL_ARB_texture_env_crossbar(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_env_dot3
#define GL_ARB_texture_env_dot3 1
#define EXTENSION_GL_ARB_texture_env_dot3(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_env_dot3) \
  CONST(GL_DOT3_RGB_ARB, 0x86AE) \
  CONST(GL_DOT3_RGBA_ARB, 0x86AF) \
  END()
#else
#define EXTENSION_GL_ARB_texture_env_dot3(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_mirrored_repeat
#define GL_ARB_texture_mirrored_repeat 1
#define EXTENSION_GL_ARB_texture_mirrored_repeat(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_mirrored_repeat) \
  CONST(GL_MIRRORED_REPEAT_ARB, 0x8370) \
  END()
#else
#define EXTENSION_GL_ARB_texture_mirrored_repeat(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_depth_texture
#define GL_ARB_depth_texture 1
#define EXTENSION_GL_ARB_depth_texture(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_depth_texture) \
  CONST(GL_DEPTH_COMPONENT16_ARB, 0x81A5) \
  CONST(GL_DEPTH_COMPONENT24_ARB, 0x81A6) \
  CONST(GL_DEPTH_COMPONENT32_ARB, 0x81A7) \
  CONST(GL_TEXTURE_DEPTH_SIZE_ARB, 0x884A) \
  CONST(GL_DEPTH_TEXTURE_MODE_ARB, 0x884B) \
  END()
#else
#define EXTENSION_GL_ARB_depth_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_shadow
#define GL_ARB_shadow 1
#define EXTENSION_GL_ARB_shadow(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_shadow) \
  CONST(GL_TEXTURE_COMPARE_MODE_ARB, 0x884C) \
  CONST(GL_TEXTURE_COMPARE_FUNC_ARB, 0x884D) \
  CONST(GL_COMPARE_R_TO_TEXTURE_ARB, 0x884E) \
  END()
#else
#define EXTENSION_GL_ARB_shadow(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_shadow_ambient
#define GL_ARB_shadow_ambient 1
#define EXTENSION_GL_ARB_shadow_ambient(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_shadow_ambient) \
  CONST(GL_TEXTURE_COMPARE_FAIL_VALUE_ARB, 0x80BF) \
  END()
#else
#define EXTENSION_GL_ARB_shadow_ambient(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_window_pos
#define GL_ARB_window_pos 1
#define EXTENSION_GL_ARB_window_pos(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_window_pos) \
  FUNC(void, glWindowPos2dARB, GLWINDOWPOS2DARB, (GLdouble x, GLdouble y)) \
  FUNC(void, glWindowPos2dvARB, GLWINDOWPOS2DVARB, (const GLdouble * v)) \
  FUNC(void, glWindowPos2fARB, GLWINDOWPOS2FARB, (GLfloat x, GLfloat y)) \
  FUNC(void, glWindowPos2fvARB, GLWINDOWPOS2FVARB, (const GLfloat * v)) \
  FUNC(void, glWindowPos2iARB, GLWINDOWPOS2IARB, (GLint x, GLint y)) \
  FUNC(void, glWindowPos2ivARB, GLWINDOWPOS2IVARB, (const GLint * v)) \
  FUNC(void, glWindowPos2sARB, GLWINDOWPOS2SARB, (GLshort x, GLshort y)) \
  FUNC(void, glWindowPos2svARB, GLWINDOWPOS2SVARB, (const GLshort * v)) \
  FUNC(void, glWindowPos3dARB, GLWINDOWPOS3DARB, (GLdouble x, GLdouble y, GLdouble z)) \
  FUNC(void, glWindowPos3dvARB, GLWINDOWPOS3DVARB, (const GLdouble * v)) \
  FUNC(void, glWindowPos3fARB, GLWINDOWPOS3FARB, (GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glWindowPos3fvARB, GLWINDOWPOS3FVARB, (const GLfloat * v)) \
  FUNC(void, glWindowPos3iARB, GLWINDOWPOS3IARB, (GLint x, GLint y, GLint z)) \
  FUNC(void, glWindowPos3ivARB, GLWINDOWPOS3IVARB, (const GLint * v)) \
  FUNC(void, glWindowPos3sARB, GLWINDOWPOS3SARB, (GLshort x, GLshort y, GLshort z)) \
  FUNC(void, glWindowPos3svARB, GLWINDOWPOS3SVARB, (const GLshort * v)) \
  END()
#else
#define EXTENSION_GL_ARB_window_pos(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_vertex_program
#define GL_ARB_vertex_program 1
#define EXTENSION_GL_ARB_vertex_program(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_vertex_program) \
  FUNC(void, glVertexAttrib1dARB, GLVERTEXATTRIB1DARB, (GLuint index, GLdouble x)) \
  FUNC(void, glVertexAttrib1dvARB, GLVERTEXATTRIB1DVARB, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib1fARB, GLVERTEXATTRIB1FARB, (GLuint index, GLfloat x)) \
  FUNC(void, glVertexAttrib1fvARB, GLVERTEXATTRIB1FVARB, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib1sARB, GLVERTEXATTRIB1SARB, (GLuint index, GLshort x)) \
  FUNC(void, glVertexAttrib1svARB, GLVERTEXATTRIB1SVARB, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib2dARB, GLVERTEXATTRIB2DARB, (GLuint index, GLdouble x, GLdouble y)) \
  FUNC(void, glVertexAttrib2dvARB, GLVERTEXATTRIB2DVARB, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib2fARB, GLVERTEXATTRIB2FARB, (GLuint index, GLfloat x, GLfloat y)) \
  FUNC(void, glVertexAttrib2fvARB, GLVERTEXATTRIB2FVARB, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib2sARB, GLVERTEXATTRIB2SARB, (GLuint index, GLshort x, GLshort y)) \
  FUNC(void, glVertexAttrib2svARB, GLVERTEXATTRIB2SVARB, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib3dARB, GLVERTEXATTRIB3DARB, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
  FUNC(void, glVertexAttrib3dvARB, GLVERTEXATTRIB3DVARB, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib3fARB, GLVERTEXATTRIB3FARB, (GLuint index, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glVertexAttrib3fvARB, GLVERTEXATTRIB3FVARB, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib3sARB, GLVERTEXATTRIB3SARB, (GLuint index, GLshort x, GLshort y, GLshort z)) \
  FUNC(void, glVertexAttrib3svARB, GLVERTEXATTRIB3SVARB, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4NbvARB, GLVERTEXATTRIB4NBVARB, (GLuint index, const GLbyte * v)) \
  FUNC(void, glVertexAttrib4NivARB, GLVERTEXATTRIB4NIVARB, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttrib4NsvARB, GLVERTEXATTRIB4NSVARB, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4NubARB, GLVERTEXATTRIB4NUBARB, (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)) \
  FUNC(void, glVertexAttrib4NubvARB, GLVERTEXATTRIB4NUBVARB, (GLuint index, const GLubyte * v)) \
  FUNC(void, glVertexAttrib4NuivARB, GLVERTEXATTRIB4NUIVARB, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttrib4NusvARB, GLVERTEXATTRIB4NUSVARB, (GLuint index, const GLushort * v)) \
  FUNC(void, glVertexAttrib4bvARB, GLVERTEXATTRIB4BVARB, (GLuint index, const GLbyte * v)) \
  FUNC(void, glVertexAttrib4dARB, GLVERTEXATTRIB4DARB, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glVertexAttrib4dvARB, GLVERTEXATTRIB4DVARB, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib4fARB, GLVERTEXATTRIB4FARB, (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glVertexAttrib4fvARB, GLVERTEXATTRIB4FVARB, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib4ivARB, GLVERTEXATTRIB4IVARB, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttrib4sARB, GLVERTEXATTRIB4SARB, (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)) \
  FUNC(void, glVertexAttrib4svARB, GLVERTEXATTRIB4SVARB, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4ubvARB, GLVERTEXATTRIB4UBVARB, (GLuint index, const GLubyte * v)) \
  FUNC(void, glVertexAttrib4uivARB, GLVERTEXATTRIB4UIVARB, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttrib4usvARB, GLVERTEXATTRIB4USVARB, (GLuint index, const GLushort * v)) \
  FUNC(void, glVertexAttribPointerARB, GLVERTEXATTRIBPOINTERARB, (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)) \
  FUNC(void, glEnableVertexAttribArrayARB, GLENABLEVERTEXATTRIBARRAYARB, (GLuint index)) \
  FUNC(void, glDisableVertexAttribArrayARB, GLDISABLEVERTEXATTRIBARRAYARB, (GLuint index)) \
  FUNC(void, glProgramStringARB, GLPROGRAMSTRINGARB, (GLenum target, GLenum format, GLsizei len, const GLvoid * string)) \
  FUNC(void, glBindProgramARB, GLBINDPROGRAMARB, (GLenum target, GLuint program)) \
  FUNC(void, glDeleteProgramsARB, GLDELETEPROGRAMSARB, (GLsizei n, const GLuint * programs)) \
  FUNC(void, glGenProgramsARB, GLGENPROGRAMSARB, (GLsizei n, GLuint * programs)) \
  FUNC(void, glProgramEnvParameter4dARB, GLPROGRAMENVPARAMETER4DARB, (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glProgramEnvParameter4dvARB, GLPROGRAMENVPARAMETER4DVARB, (GLenum target, GLuint index, const GLdouble * params)) \
  FUNC(void, glProgramEnvParameter4fARB, GLPROGRAMENVPARAMETER4FARB, (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glProgramEnvParameter4fvARB, GLPROGRAMENVPARAMETER4FVARB, (GLenum target, GLuint index, const GLfloat * params)) \
  FUNC(void, glProgramLocalParameter4dARB, GLPROGRAMLOCALPARAMETER4DARB, (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glProgramLocalParameter4dvARB, GLPROGRAMLOCALPARAMETER4DVARB, (GLenum target, GLuint index, const GLdouble * params)) \
  FUNC(void, glProgramLocalParameter4fARB, GLPROGRAMLOCALPARAMETER4FARB, (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glProgramLocalParameter4fvARB, GLPROGRAMLOCALPARAMETER4FVARB, (GLenum target, GLuint index, const GLfloat * params)) \
  FUNC(void, glGetProgramEnvParameterdvARB, GLGETPROGRAMENVPARAMETERDVARB, (GLenum target, GLuint index, GLdouble * params)) \
  FUNC(void, glGetProgramEnvParameterfvARB, GLGETPROGRAMENVPARAMETERFVARB, (GLenum target, GLuint index, GLfloat * params)) \
  FUNC(void, glGetProgramLocalParameterdvARB, GLGETPROGRAMLOCALPARAMETERDVARB, (GLenum target, GLuint index, GLdouble * params)) \
  FUNC(void, glGetProgramLocalParameterfvARB, GLGETPROGRAMLOCALPARAMETERFVARB, (GLenum target, GLuint index, GLfloat * params)) \
  FUNC(void, glGetProgramivARB, GLGETPROGRAMIVARB, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetProgramStringARB, GLGETPROGRAMSTRINGARB, (GLenum target, GLenum pname, GLvoid * string)) \
  FUNC(void, glGetVertexAttribdvARB, GLGETVERTEXATTRIBDVARB, (GLuint index, GLenum pname, GLdouble * params)) \
  FUNC(void, glGetVertexAttribfvARB, GLGETVERTEXATTRIBFVARB, (GLuint index, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetVertexAttribivARB, GLGETVERTEXATTRIBIVARB, (GLuint index, GLenum pname, GLint * params)) \
  FUNC(void, glGetVertexAttribPointervARB, GLGETVERTEXATTRIBPOINTERVARB, (GLuint index, GLenum pname, GLvoid* * pointer)) \
  FUNC(GLboolean, glIsProgramARB, GLISPROGRAMARB, (GLuint program)) \
  CONST(GL_COLOR_SUM_ARB, 0x8458) \
  CONST(GL_VERTEX_PROGRAM_ARB, 0x8620) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, 0x8622) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB, 0x8623) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB, 0x8624) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB, 0x8625) \
  CONST(GL_CURRENT_VERTEX_ATTRIB_ARB, 0x8626) \
  CONST(GL_PROGRAM_LENGTH_ARB, 0x8627) \
  CONST(GL_PROGRAM_STRING_ARB, 0x8628) \
  CONST(GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, 0x862E) \
  CONST(GL_MAX_PROGRAM_MATRICES_ARB, 0x862F) \
  CONST(GL_CURRENT_MATRIX_STACK_DEPTH_ARB, 0x8640) \
  CONST(GL_CURRENT_MATRIX_ARB, 0x8641) \
  CONST(GL_VERTEX_PROGRAM_POINT_SIZE_ARB, 0x8642) \
  CONST(GL_VERTEX_PROGRAM_TWO_SIDE_ARB, 0x8643) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, 0x8645) \
  CONST(GL_PROGRAM_ERROR_POSITION_ARB, 0x864B) \
  CONST(GL_PROGRAM_BINDING_ARB, 0x8677) \
  CONST(GL_MAX_VERTEX_ATTRIBS_ARB, 0x8869) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB, 0x886A) \
  CONST(GL_PROGRAM_ERROR_STRING_ARB, 0x8874) \
  CONST(GL_PROGRAM_FORMAT_ASCII_ARB, 0x8875) \
  CONST(GL_PROGRAM_FORMAT_ARB, 0x8876) \
  CONST(GL_PROGRAM_INSTRUCTIONS_ARB, 0x88A0) \
  CONST(GL_MAX_PROGRAM_INSTRUCTIONS_ARB, 0x88A1) \
  CONST(GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB, 0x88A2) \
  CONST(GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, 0x88A3) \
  CONST(GL_PROGRAM_TEMPORARIES_ARB, 0x88A4) \
  CONST(GL_MAX_PROGRAM_TEMPORARIES_ARB, 0x88A5) \
  CONST(GL_PROGRAM_NATIVE_TEMPORARIES_ARB, 0x88A6) \
  CONST(GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, 0x88A7) \
  CONST(GL_PROGRAM_PARAMETERS_ARB, 0x88A8) \
  CONST(GL_MAX_PROGRAM_PARAMETERS_ARB, 0x88A9) \
  CONST(GL_PROGRAM_NATIVE_PARAMETERS_ARB, 0x88AA) \
  CONST(GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, 0x88AB) \
  CONST(GL_PROGRAM_ATTRIBS_ARB, 0x88AC) \
  CONST(GL_MAX_PROGRAM_ATTRIBS_ARB, 0x88AD) \
  CONST(GL_PROGRAM_NATIVE_ATTRIBS_ARB, 0x88AE) \
  CONST(GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, 0x88AF) \
  CONST(GL_PROGRAM_ADDRESS_REGISTERS_ARB, 0x88B0) \
  CONST(GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, 0x88B1) \
  CONST(GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, 0x88B2) \
  CONST(GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, 0x88B3) \
  CONST(GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, 0x88B4) \
  CONST(GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, 0x88B5) \
  CONST(GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, 0x88B6) \
  CONST(GL_TRANSPOSE_CURRENT_MATRIX_ARB, 0x88B7) \
  CONST(GL_MATRIX0_ARB, 0x88C0) \
  CONST(GL_MATRIX1_ARB, 0x88C1) \
  CONST(GL_MATRIX2_ARB, 0x88C2) \
  CONST(GL_MATRIX3_ARB, 0x88C3) \
  CONST(GL_MATRIX4_ARB, 0x88C4) \
  CONST(GL_MATRIX5_ARB, 0x88C5) \
  CONST(GL_MATRIX6_ARB, 0x88C6) \
  CONST(GL_MATRIX7_ARB, 0x88C7) \
  CONST(GL_MATRIX8_ARB, 0x88C8) \
  CONST(GL_MATRIX9_ARB, 0x88C9) \
  CONST(GL_MATRIX10_ARB, 0x88CA) \
  CONST(GL_MATRIX11_ARB, 0x88CB) \
  CONST(GL_MATRIX12_ARB, 0x88CC) \
  CONST(GL_MATRIX13_ARB, 0x88CD) \
  CONST(GL_MATRIX14_ARB, 0x88CE) \
  CONST(GL_MATRIX15_ARB, 0x88CF) \
  CONST(GL_MATRIX16_ARB, 0x88D0) \
  CONST(GL_MATRIX17_ARB, 0x88D1) \
  CONST(GL_MATRIX18_ARB, 0x88D2) \
  CONST(GL_MATRIX19_ARB, 0x88D3) \
  CONST(GL_MATRIX20_ARB, 0x88D4) \
  CONST(GL_MATRIX21_ARB, 0x88D5) \
  CONST(GL_MATRIX22_ARB, 0x88D6) \
  CONST(GL_MATRIX23_ARB, 0x88D7) \
  CONST(GL_MATRIX24_ARB, 0x88D8) \
  CONST(GL_MATRIX25_ARB, 0x88D9) \
  CONST(GL_MATRIX26_ARB, 0x88DA) \
  CONST(GL_MATRIX27_ARB, 0x88DB) \
  CONST(GL_MATRIX28_ARB, 0x88DC) \
  CONST(GL_MATRIX29_ARB, 0x88DD) \
  CONST(GL_MATRIX30_ARB, 0x88DE) \
  CONST(GL_MATRIX31_ARB, 0x88DF) \
  END()
#else
#define EXTENSION_GL_ARB_vertex_program(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_fragment_program
#define GL_ARB_fragment_program 1
#define EXTENSION_GL_ARB_fragment_program(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_fragment_program) \
  CONST(GL_FRAGMENT_PROGRAM_ARB, 0x8804) \
  CONST(GL_PROGRAM_ALU_INSTRUCTIONS_ARB, 0x8805) \
  CONST(GL_PROGRAM_TEX_INSTRUCTIONS_ARB, 0x8806) \
  CONST(GL_PROGRAM_TEX_INDIRECTIONS_ARB, 0x8807) \
  CONST(GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, 0x8808) \
  CONST(GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, 0x8809) \
  CONST(GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, 0x880A) \
  CONST(GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, 0x880B) \
  CONST(GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, 0x880C) \
  CONST(GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, 0x880D) \
  CONST(GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, 0x880E) \
  CONST(GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, 0x880F) \
  CONST(GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, 0x8810) \
  CONST(GL_MAX_TEXTURE_COORDS_ARB, 0x8871) \
  CONST(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, 0x8872) \
  END()
#else
#define EXTENSION_GL_ARB_fragment_program(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_vertex_buffer_object
#define GL_ARB_vertex_buffer_object 1
#define EXTENSION_GL_ARB_vertex_buffer_object(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_vertex_buffer_object) \
  FUNC(void, glBindBufferARB, GLBINDBUFFERARB, (GLenum target, GLuint buffer)) \
  FUNC(void, glDeleteBuffersARB, GLDELETEBUFFERSARB, (GLsizei n, const GLuint * buffers)) \
  FUNC(void, glGenBuffersARB, GLGENBUFFERSARB, (GLsizei n, GLuint * buffers)) \
  FUNC(GLboolean, glIsBufferARB, GLISBUFFERARB, (GLuint buffer)) \
  FUNC(void, glBufferDataARB, GLBUFFERDATAARB, (GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage)) \
  FUNC(void, glBufferSubDataARB, GLBUFFERSUBDATAARB, (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data)) \
  FUNC(void, glGetBufferSubDataARB, GLGETBUFFERSUBDATAARB, (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data)) \
  FUNC(GLvoid*, glMapBufferARB, GLMAPBUFFERARB, (GLenum target, GLenum access)) \
  FUNC(GLboolean, glUnmapBufferARB, GLUNMAPBUFFERARB, (GLenum target)) \
  FUNC(void, glGetBufferParameterivARB, GLGETBUFFERPARAMETERIVARB, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetBufferPointervARB, GLGETBUFFERPOINTERVARB, (GLenum target, GLenum pname, GLvoid* * params)) \
  CONST(GL_BUFFER_SIZE_ARB, 0x8764) \
  CONST(GL_BUFFER_USAGE_ARB, 0x8765) \
  CONST(GL_ARRAY_BUFFER_ARB, 0x8892) \
  CONST(GL_ELEMENT_ARRAY_BUFFER_ARB, 0x8893) \
  CONST(GL_ARRAY_BUFFER_BINDING_ARB, 0x8894) \
  CONST(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, 0x8895) \
  CONST(GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, 0x8896) \
  CONST(GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, 0x8897) \
  CONST(GL_COLOR_ARRAY_BUFFER_BINDING_ARB, 0x8898) \
  CONST(GL_INDEX_ARRAY_BUFFER_BINDING_ARB, 0x8899) \
  CONST(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, 0x889A) \
  CONST(GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, 0x889B) \
  CONST(GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, 0x889C) \
  CONST(GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, 0x889D) \
  CONST(GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB, 0x889E) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB, 0x889F) \
  CONST(GL_READ_ONLY_ARB, 0x88B8) \
  CONST(GL_WRITE_ONLY_ARB, 0x88B9) \
  CONST(GL_READ_WRITE_ARB, 0x88BA) \
  CONST(GL_BUFFER_ACCESS_ARB, 0x88BB) \
  CONST(GL_BUFFER_MAPPED_ARB, 0x88BC) \
  CONST(GL_BUFFER_MAP_POINTER_ARB, 0x88BD) \
  CONST(GL_STREAM_DRAW_ARB, 0x88E0) \
  CONST(GL_STREAM_READ_ARB, 0x88E1) \
  CONST(GL_STREAM_COPY_ARB, 0x88E2) \
  CONST(GL_STATIC_DRAW_ARB, 0x88E4) \
  CONST(GL_STATIC_READ_ARB, 0x88E5) \
  CONST(GL_STATIC_COPY_ARB, 0x88E6) \
  CONST(GL_DYNAMIC_DRAW_ARB, 0x88E8) \
  CONST(GL_DYNAMIC_READ_ARB, 0x88E9) \
  CONST(GL_DYNAMIC_COPY_ARB, 0x88EA) \
  END()
#else
#define EXTENSION_GL_ARB_vertex_buffer_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_occlusion_query
#define GL_ARB_occlusion_query 1
#define EXTENSION_GL_ARB_occlusion_query(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_occlusion_query) \
  FUNC(void, glGenQueriesARB, GLGENQUERIESARB, (GLsizei n, GLuint * ids)) \
  FUNC(void, glDeleteQueriesARB, GLDELETEQUERIESARB, (GLsizei n, const GLuint * ids)) \
  FUNC(GLboolean, glIsQueryARB, GLISQUERYARB, (GLuint id)) \
  FUNC(void, glBeginQueryARB, GLBEGINQUERYARB, (GLenum target, GLuint id)) \
  FUNC(void, glEndQueryARB, GLENDQUERYARB, (GLenum target)) \
  FUNC(void, glGetQueryivARB, GLGETQUERYIVARB, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetQueryObjectivARB, GLGETQUERYOBJECTIVARB, (GLuint id, GLenum pname, GLint * params)) \
  FUNC(void, glGetQueryObjectuivARB, GLGETQUERYOBJECTUIVARB, (GLuint id, GLenum pname, GLuint * params)) \
  CONST(GL_QUERY_COUNTER_BITS_ARB, 0x8864) \
  CONST(GL_CURRENT_QUERY_ARB, 0x8865) \
  CONST(GL_QUERY_RESULT_ARB, 0x8866) \
  CONST(GL_QUERY_RESULT_AVAILABLE_ARB, 0x8867) \
  CONST(GL_SAMPLES_PASSED_ARB, 0x8914) \
  END()
#else
#define EXTENSION_GL_ARB_occlusion_query(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_shader_objects
#define GL_ARB_shader_objects 1
#define EXTENSION_GL_ARB_shader_objects(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_shader_objects) \
  FUNC(void, glDeleteObjectARB, GLDELETEOBJECTARB, (GLhandleARB obj)) \
  FUNC(GLhandleARB, glGetHandleARB, GLGETHANDLEARB, (GLenum pname)) \
  FUNC(void, glDetachObjectARB, GLDETACHOBJECTARB, (GLhandleARB containerObj, GLhandleARB attachedObj)) \
  FUNC(GLhandleARB, glCreateShaderObjectARB, GLCREATESHADEROBJECTARB, (GLenum shaderType)) \
  FUNC(void, glShaderSourceARB, GLSHADERSOURCEARB, (GLhandleARB shaderObj, GLsizei count, const GLcharARB* * string, const GLint * length)) \
  FUNC(void, glCompileShaderARB, GLCOMPILESHADERARB, (GLhandleARB shaderObj)) \
  FUNC(GLhandleARB, glCreateProgramObjectARB, GLCREATEPROGRAMOBJECTARB, ()) \
  FUNC(void, glAttachObjectARB, GLATTACHOBJECTARB, (GLhandleARB containerObj, GLhandleARB obj)) \
  FUNC(void, glLinkProgramARB, GLLINKPROGRAMARB, (GLhandleARB programObj)) \
  FUNC(void, glUseProgramObjectARB, GLUSEPROGRAMOBJECTARB, (GLhandleARB programObj)) \
  FUNC(void, glValidateProgramARB, GLVALIDATEPROGRAMARB, (GLhandleARB programObj)) \
  FUNC(void, glUniform1fARB, GLUNIFORM1FARB, (GLint location, GLfloat v0)) \
  FUNC(void, glUniform2fARB, GLUNIFORM2FARB, (GLint location, GLfloat v0, GLfloat v1)) \
  FUNC(void, glUniform3fARB, GLUNIFORM3FARB, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) \
  FUNC(void, glUniform4fARB, GLUNIFORM4FARB, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) \
  FUNC(void, glUniform1iARB, GLUNIFORM1IARB, (GLint location, GLint v0)) \
  FUNC(void, glUniform2iARB, GLUNIFORM2IARB, (GLint location, GLint v0, GLint v1)) \
  FUNC(void, glUniform3iARB, GLUNIFORM3IARB, (GLint location, GLint v0, GLint v1, GLint v2)) \
  FUNC(void, glUniform4iARB, GLUNIFORM4IARB, (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) \
  FUNC(void, glUniform1fvARB, GLUNIFORM1FVARB, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform2fvARB, GLUNIFORM2FVARB, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform3fvARB, GLUNIFORM3FVARB, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform4fvARB, GLUNIFORM4FVARB, (GLint location, GLsizei count, const GLfloat * value)) \
  FUNC(void, glUniform1ivARB, GLUNIFORM1IVARB, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniform2ivARB, GLUNIFORM2IVARB, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniform3ivARB, GLUNIFORM3IVARB, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniform4ivARB, GLUNIFORM4IVARB, (GLint location, GLsizei count, const GLint * value)) \
  FUNC(void, glUniformMatrix2fvARB, GLUNIFORMMATRIX2FVARB, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix3fvARB, GLUNIFORMMATRIX3FVARB, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glUniformMatrix4fvARB, GLUNIFORMMATRIX4FVARB, (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)) \
  FUNC(void, glGetObjectParameterfvARB, GLGETOBJECTPARAMETERFVARB, (GLhandleARB obj, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetObjectParameterivARB, GLGETOBJECTPARAMETERIVARB, (GLhandleARB obj, GLenum pname, GLint * params)) \
  FUNC(void, glGetInfoLogARB, GLGETINFOLOGARB, (GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)) \
  FUNC(void, glGetAttachedObjectsARB, GLGETATTACHEDOBJECTSARB, (GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj)) \
  FUNC(GLint, glGetUniformLocationARB, GLGETUNIFORMLOCATIONARB, (GLhandleARB programObj, const GLcharARB * name)) \
  FUNC(void, glGetActiveUniformARB, GLGETACTIVEUNIFORMARB, (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name)) \
  FUNC(void, glGetUniformfvARB, GLGETUNIFORMFVARB, (GLhandleARB programObj, GLint location, GLfloat * params)) \
  FUNC(void, glGetUniformivARB, GLGETUNIFORMIVARB, (GLhandleARB programObj, GLint location, GLint * params)) \
  FUNC(void, glGetShaderSourceARB, GLGETSHADERSOURCEARB, (GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * source)) \
  CONST(GL_PROGRAM_OBJECT_ARB, 0x8B40) \
  CONST(GL_SHADER_OBJECT_ARB, 0x8B48) \
  CONST(GL_OBJECT_TYPE_ARB, 0x8B4E) \
  CONST(GL_OBJECT_SUBTYPE_ARB, 0x8B4F) \
  CONST(GL_FLOAT_VEC2_ARB, 0x8B50) \
  CONST(GL_FLOAT_VEC3_ARB, 0x8B51) \
  CONST(GL_FLOAT_VEC4_ARB, 0x8B52) \
  CONST(GL_INT_VEC2_ARB, 0x8B53) \
  CONST(GL_INT_VEC3_ARB, 0x8B54) \
  CONST(GL_INT_VEC4_ARB, 0x8B55) \
  CONST(GL_BOOL_ARB, 0x8B56) \
  CONST(GL_BOOL_VEC2_ARB, 0x8B57) \
  CONST(GL_BOOL_VEC3_ARB, 0x8B58) \
  CONST(GL_BOOL_VEC4_ARB, 0x8B59) \
  CONST(GL_FLOAT_MAT2_ARB, 0x8B5A) \
  CONST(GL_FLOAT_MAT3_ARB, 0x8B5B) \
  CONST(GL_FLOAT_MAT4_ARB, 0x8B5C) \
  CONST(GL_SAMPLER_1D_ARB, 0x8B5D) \
  CONST(GL_SAMPLER_2D_ARB, 0x8B5E) \
  CONST(GL_SAMPLER_3D_ARB, 0x8B5F) \
  CONST(GL_SAMPLER_CUBE_ARB, 0x8B60) \
  CONST(GL_SAMPLER_1D_SHADOW_ARB, 0x8B61) \
  CONST(GL_SAMPLER_2D_SHADOW_ARB, 0x8B62) \
  CONST(GL_SAMPLER_2D_RECT_ARB, 0x8B63) \
  CONST(GL_SAMPLER_2D_RECT_SHADOW_ARB, 0x8B64) \
  CONST(GL_OBJECT_DELETE_STATUS_ARB, 0x8B80) \
  CONST(GL_OBJECT_COMPILE_STATUS_ARB, 0x8B81) \
  CONST(GL_OBJECT_LINK_STATUS_ARB, 0x8B82) \
  CONST(GL_OBJECT_VALIDATE_STATUS_ARB, 0x8B83) \
  CONST(GL_OBJECT_INFO_LOG_LENGTH_ARB, 0x8B84) \
  CONST(GL_OBJECT_ATTACHED_OBJECTS_ARB, 0x8B85) \
  CONST(GL_OBJECT_ACTIVE_UNIFORMS_ARB, 0x8B86) \
  CONST(GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB, 0x8B87) \
  CONST(GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, 0x8B88) \
  END()
#else
#define EXTENSION_GL_ARB_shader_objects(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_vertex_shader
#define GL_ARB_vertex_shader 1
#define EXTENSION_GL_ARB_vertex_shader(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_vertex_shader) \
  FUNC(void, glBindAttribLocationARB, GLBINDATTRIBLOCATIONARB, (GLhandleARB programObj, GLuint index, const GLcharARB * name)) \
  FUNC(void, glGetActiveAttribARB, GLGETACTIVEATTRIBARB, (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name)) \
  FUNC(GLint, glGetAttribLocationARB, GLGETATTRIBLOCATIONARB, (GLhandleARB programObj, const GLcharARB * name)) \
  CONST(GL_VERTEX_SHADER_ARB, 0x8B31) \
  CONST(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, 0x8B4A) \
  CONST(GL_MAX_VARYING_FLOATS_ARB, 0x8B4B) \
  CONST(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, 0x8B4C) \
  CONST(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, 0x8B4D) \
  CONST(GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, 0x8B89) \
  CONST(GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB, 0x8B8A) \
  END()
#else
#define EXTENSION_GL_ARB_vertex_shader(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_fragment_shader
#define GL_ARB_fragment_shader 1
#define EXTENSION_GL_ARB_fragment_shader(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_fragment_shader) \
  CONST(GL_FRAGMENT_SHADER_ARB, 0x8B30) \
  CONST(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, 0x8B49) \
  CONST(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB, 0x8B8B) \
  END()
#else
#define EXTENSION_GL_ARB_fragment_shader(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_shading_language_100
#define GL_ARB_shading_language_100 1
#define EXTENSION_GL_ARB_shading_language_100(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_shading_language_100) \
  CONST(GL_SHADING_LANGUAGE_VERSION_ARB, 0x8B8C) \
  END()
#else
#define EXTENSION_GL_ARB_shading_language_100(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_non_power_of_two
#define GL_ARB_texture_non_power_of_two 1
#define EXTENSION_GL_ARB_texture_non_power_of_two(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_non_power_of_two) \
  END()
#else
#define EXTENSION_GL_ARB_texture_non_power_of_two(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_point_sprite
#define GL_ARB_point_sprite 1
#define EXTENSION_GL_ARB_point_sprite(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_point_sprite) \
  CONST(GL_POINT_SPRITE_ARB, 0x8861) \
  CONST(GL_COORD_REPLACE_ARB, 0x8862) \
  END()
#else
#define EXTENSION_GL_ARB_point_sprite(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_fragment_program_shadow
#define GL_ARB_fragment_program_shadow 1
#define EXTENSION_GL_ARB_fragment_program_shadow(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_fragment_program_shadow) \
  END()
#else
#define EXTENSION_GL_ARB_fragment_program_shadow(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_draw_buffers
#define GL_ARB_draw_buffers 1
#define EXTENSION_GL_ARB_draw_buffers(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_draw_buffers) \
  FUNC(void, glDrawBuffersARB, GLDRAWBUFFERSARB, (GLsizei n, const GLenum * bufs)) \
  CONST(GL_MAX_DRAW_BUFFERS_ARB, 0x8824) \
  CONST(GL_DRAW_BUFFER0_ARB, 0x8825) \
  CONST(GL_DRAW_BUFFER1_ARB, 0x8826) \
  CONST(GL_DRAW_BUFFER2_ARB, 0x8827) \
  CONST(GL_DRAW_BUFFER3_ARB, 0x8828) \
  CONST(GL_DRAW_BUFFER4_ARB, 0x8829) \
  CONST(GL_DRAW_BUFFER5_ARB, 0x882A) \
  CONST(GL_DRAW_BUFFER6_ARB, 0x882B) \
  CONST(GL_DRAW_BUFFER7_ARB, 0x882C) \
  CONST(GL_DRAW_BUFFER8_ARB, 0x882D) \
  CONST(GL_DRAW_BUFFER9_ARB, 0x882E) \
  CONST(GL_DRAW_BUFFER10_ARB, 0x882F) \
  CONST(GL_DRAW_BUFFER11_ARB, 0x8830) \
  CONST(GL_DRAW_BUFFER12_ARB, 0x8831) \
  CONST(GL_DRAW_BUFFER13_ARB, 0x8832) \
  CONST(GL_DRAW_BUFFER14_ARB, 0x8833) \
  CONST(GL_DRAW_BUFFER15_ARB, 0x8834) \
  END()
#else
#define EXTENSION_GL_ARB_draw_buffers(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_rectangle
#define GL_ARB_texture_rectangle 1
#define EXTENSION_GL_ARB_texture_rectangle(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_rectangle) \
  CONST(GL_TEXTURE_RECTANGLE_ARB, 0x84F5) \
  CONST(GL_TEXTURE_BINDING_RECTANGLE_ARB, 0x84F6) \
  CONST(GL_PROXY_TEXTURE_RECTANGLE_ARB, 0x84F7) \
  CONST(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, 0x84F8) \
  END()
#else
#define EXTENSION_GL_ARB_texture_rectangle(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_color_buffer_float
#define GL_ARB_color_buffer_float 1
#define EXTENSION_GL_ARB_color_buffer_float(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_color_buffer_float) \
  FUNC(void, glClampColorARB, GLCLAMPCOLORARB, (GLenum target, GLenum clamp)) \
  CONST(GL_RGBA_FLOAT_MODE_ARB, 0x8820) \
  CONST(GL_CLAMP_VERTEX_COLOR_ARB, 0x891A) \
  CONST(GL_CLAMP_FRAGMENT_COLOR_ARB, 0x891B) \
  CONST(GL_CLAMP_READ_COLOR_ARB, 0x891C) \
  CONST(GL_FIXED_ONLY_ARB, 0x891D) \
  END()
#else
#define EXTENSION_GL_ARB_color_buffer_float(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_half_float_pixel
#define GL_ARB_half_float_pixel 1
#define EXTENSION_GL_ARB_half_float_pixel(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_half_float_pixel) \
  CONST(GL_HALF_FLOAT_ARB, 0x140B) \
  END()
#else
#define EXTENSION_GL_ARB_half_float_pixel(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_texture_float
#define GL_ARB_texture_float 1
#define EXTENSION_GL_ARB_texture_float(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_texture_float) \
  CONST(GL_TEXTURE_RED_TYPE_ARB, 0x8C10) \
  CONST(GL_TEXTURE_GREEN_TYPE_ARB, 0x8C11) \
  CONST(GL_TEXTURE_BLUE_TYPE_ARB, 0x8C12) \
  CONST(GL_TEXTURE_ALPHA_TYPE_ARB, 0x8C13) \
  CONST(GL_TEXTURE_LUMINANCE_TYPE_ARB, 0x8C14) \
  CONST(GL_TEXTURE_INTENSITY_TYPE_ARB, 0x8C15) \
  CONST(GL_TEXTURE_DEPTH_TYPE_ARB, 0x8C16) \
  CONST(GL_UNSIGNED_NORMALIZED_ARB, 0x8C17) \
  CONST(GL_RGBA32F_ARB, 0x8814) \
  CONST(GL_RGB32F_ARB, 0x8815) \
  CONST(GL_ALPHA32F_ARB, 0x8816) \
  CONST(GL_INTENSITY32F_ARB, 0x8817) \
  CONST(GL_LUMINANCE32F_ARB, 0x8818) \
  CONST(GL_LUMINANCE_ALPHA32F_ARB, 0x8819) \
  CONST(GL_RGBA16F_ARB, 0x881A) \
  CONST(GL_RGB16F_ARB, 0x881B) \
  CONST(GL_ALPHA16F_ARB, 0x881C) \
  CONST(GL_INTENSITY16F_ARB, 0x881D) \
  CONST(GL_LUMINANCE16F_ARB, 0x881E) \
  CONST(GL_LUMINANCE_ALPHA16F_ARB, 0x881F) \
  END()
#else
#define EXTENSION_GL_ARB_texture_float(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ARB_pixel_buffer_object
#define GL_ARB_pixel_buffer_object 1
#define EXTENSION_GL_ARB_pixel_buffer_object(NAME, FUNC, CONST, END) \
  NAME(GL_ARB_pixel_buffer_object) \
  CONST(GL_PIXEL_PACK_BUFFER_ARB, 0x88EB) \
  CONST(GL_PIXEL_UNPACK_BUFFER_ARB, 0x88EC) \
  CONST(GL_PIXEL_PACK_BUFFER_BINDING_ARB, 0x88ED) \
  CONST(GL_PIXEL_UNPACK_BUFFER_BINDING_ARB, 0x88EF) \
  END()
#else
#define EXTENSION_GL_ARB_pixel_buffer_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_abgr
#define GL_EXT_abgr 1
#define EXTENSION_GL_EXT_abgr(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_abgr) \
  CONST(GL_ABGR_EXT, 0x8000) \
  END()
#else
#define EXTENSION_GL_EXT_abgr(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_blend_color
#define GL_EXT_blend_color 1
#define EXTENSION_GL_EXT_blend_color(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_blend_color) \
  FUNC(void, glBlendColorEXT, GLBLENDCOLOREXT, (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)) \
  CONST(GL_CONSTANT_COLOR_EXT, 0x8001) \
  CONST(GL_ONE_MINUS_CONSTANT_COLOR_EXT, 0x8002) \
  CONST(GL_CONSTANT_ALPHA_EXT, 0x8003) \
  CONST(GL_ONE_MINUS_CONSTANT_ALPHA_EXT, 0x8004) \
  CONST(GL_BLEND_COLOR_EXT, 0x8005) \
  END()
#else
#define EXTENSION_GL_EXT_blend_color(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_polygon_offset
#define GL_EXT_polygon_offset 1
#define EXTENSION_GL_EXT_polygon_offset(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_polygon_offset) \
  FUNC(void, glPolygonOffsetEXT, GLPOLYGONOFFSETEXT, (GLfloat factor, GLfloat bias)) \
  CONST(GL_POLYGON_OFFSET_EXT, 0x8037) \
  CONST(GL_POLYGON_OFFSET_FACTOR_EXT, 0x8038) \
  CONST(GL_POLYGON_OFFSET_BIAS_EXT, 0x8039) \
  END()
#else
#define EXTENSION_GL_EXT_polygon_offset(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture
#define GL_EXT_texture 1
#define EXTENSION_GL_EXT_texture(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture) \
  CONST(GL_ALPHA4_EXT, 0x803B) \
  CONST(GL_ALPHA8_EXT, 0x803C) \
  CONST(GL_ALPHA12_EXT, 0x803D) \
  CONST(GL_ALPHA16_EXT, 0x803E) \
  CONST(GL_LUMINANCE4_EXT, 0x803F) \
  CONST(GL_LUMINANCE8_EXT, 0x8040) \
  CONST(GL_LUMINANCE12_EXT, 0x8041) \
  CONST(GL_LUMINANCE16_EXT, 0x8042) \
  CONST(GL_LUMINANCE4_ALPHA4_EXT, 0x8043) \
  CONST(GL_LUMINANCE6_ALPHA2_EXT, 0x8044) \
  CONST(GL_LUMINANCE8_ALPHA8_EXT, 0x8045) \
  CONST(GL_LUMINANCE12_ALPHA4_EXT, 0x8046) \
  CONST(GL_LUMINANCE12_ALPHA12_EXT, 0x8047) \
  CONST(GL_LUMINANCE16_ALPHA16_EXT, 0x8048) \
  CONST(GL_INTENSITY_EXT, 0x8049) \
  CONST(GL_INTENSITY4_EXT, 0x804A) \
  CONST(GL_INTENSITY8_EXT, 0x804B) \
  CONST(GL_INTENSITY12_EXT, 0x804C) \
  CONST(GL_INTENSITY16_EXT, 0x804D) \
  CONST(GL_RGB2_EXT, 0x804E) \
  CONST(GL_RGB4_EXT, 0x804F) \
  CONST(GL_RGB5_EXT, 0x8050) \
  CONST(GL_RGB8_EXT, 0x8051) \
  CONST(GL_RGB10_EXT, 0x8052) \
  CONST(GL_RGB12_EXT, 0x8053) \
  CONST(GL_RGB16_EXT, 0x8054) \
  CONST(GL_RGBA2_EXT, 0x8055) \
  CONST(GL_RGBA4_EXT, 0x8056) \
  CONST(GL_RGB5_A1_EXT, 0x8057) \
  CONST(GL_RGBA8_EXT, 0x8058) \
  CONST(GL_RGB10_A2_EXT, 0x8059) \
  CONST(GL_RGBA12_EXT, 0x805A) \
  CONST(GL_RGBA16_EXT, 0x805B) \
  CONST(GL_TEXTURE_RED_SIZE_EXT, 0x805C) \
  CONST(GL_TEXTURE_GREEN_SIZE_EXT, 0x805D) \
  CONST(GL_TEXTURE_BLUE_SIZE_EXT, 0x805E) \
  CONST(GL_TEXTURE_ALPHA_SIZE_EXT, 0x805F) \
  CONST(GL_TEXTURE_LUMINANCE_SIZE_EXT, 0x8060) \
  CONST(GL_TEXTURE_INTENSITY_SIZE_EXT, 0x8061) \
  CONST(GL_REPLACE_EXT, 0x8062) \
  CONST(GL_PROXY_TEXTURE_1D_EXT, 0x8063) \
  CONST(GL_PROXY_TEXTURE_2D_EXT, 0x8064) \
  CONST(GL_TEXTURE_TOO_LARGE_EXT, 0x8065) \
  END()
#else
#define EXTENSION_GL_EXT_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture3D
#define GL_EXT_texture3D 1
#define EXTENSION_GL_EXT_texture3D(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture3D) \
  FUNC(void, glTexImage3DEXT, GLTEXIMAGE3DEXT, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)) \
  FUNC(void, glTexSubImage3DEXT, GLTEXSUBIMAGE3DEXT, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)) \
  CONST(GL_PACK_SKIP_IMAGES_EXT, 0x806B) \
  CONST(GL_PACK_IMAGE_HEIGHT_EXT, 0x806C) \
  CONST(GL_UNPACK_SKIP_IMAGES_EXT, 0x806D) \
  CONST(GL_UNPACK_IMAGE_HEIGHT_EXT, 0x806E) \
  CONST(GL_TEXTURE_3D_EXT, 0x806F) \
  CONST(GL_PROXY_TEXTURE_3D_EXT, 0x8070) \
  CONST(GL_TEXTURE_DEPTH_EXT, 0x8071) \
  CONST(GL_TEXTURE_WRAP_R_EXT, 0x8072) \
  CONST(GL_MAX_3D_TEXTURE_SIZE_EXT, 0x8073) \
  END()
#else
#define EXTENSION_GL_EXT_texture3D(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_texture_filter4
#define GL_SGIS_texture_filter4 1
#define EXTENSION_GL_SGIS_texture_filter4(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_texture_filter4) \
  FUNC(void, glGetTexFilterFuncSGIS, GLGETTEXFILTERFUNCSGIS, (GLenum target, GLenum filter, GLfloat * weights)) \
  FUNC(void, glTexFilterFuncSGIS, GLTEXFILTERFUNCSGIS, (GLenum target, GLenum filter, GLsizei n, const GLfloat * weights)) \
  CONST(GL_FILTER4_SGIS, 0x8146) \
  CONST(GL_TEXTURE_FILTER4_SIZE_SGIS, 0x8147) \
  END()
#else
#define EXTENSION_GL_SGIS_texture_filter4(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_subtexture
#define GL_EXT_subtexture 1
#define EXTENSION_GL_EXT_subtexture(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_subtexture) \
  FUNC(void, glTexSubImage1DEXT, GLTEXSUBIMAGE1DEXT, (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)) \
  FUNC(void, glTexSubImage2DEXT, GLTEXSUBIMAGE2DEXT, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)) \
  END()
#else
#define EXTENSION_GL_EXT_subtexture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_copy_texture
#define GL_EXT_copy_texture 1
#define EXTENSION_GL_EXT_copy_texture(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_copy_texture) \
  FUNC(void, glCopyTexImage1DEXT, GLCOPYTEXIMAGE1DEXT, (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)) \
  FUNC(void, glCopyTexImage2DEXT, GLCOPYTEXIMAGE2DEXT, (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)) \
  FUNC(void, glCopyTexSubImage1DEXT, GLCOPYTEXSUBIMAGE1DEXT, (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)) \
  FUNC(void, glCopyTexSubImage2DEXT, GLCOPYTEXSUBIMAGE2DEXT, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
  FUNC(void, glCopyTexSubImage3DEXT, GLCOPYTEXSUBIMAGE3DEXT, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
  END()
#else
#define EXTENSION_GL_EXT_copy_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_histogram
#define GL_EXT_histogram 1
#define EXTENSION_GL_EXT_histogram(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_histogram) \
  FUNC(void, glGetHistogramEXT, GLGETHISTOGRAMEXT, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)) \
  FUNC(void, glGetHistogramParameterfvEXT, GLGETHISTOGRAMPARAMETERFVEXT, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetHistogramParameterivEXT, GLGETHISTOGRAMPARAMETERIVEXT, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetMinmaxEXT, GLGETMINMAXEXT, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)) \
  FUNC(void, glGetMinmaxParameterfvEXT, GLGETMINMAXPARAMETERFVEXT, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetMinmaxParameterivEXT, GLGETMINMAXPARAMETERIVEXT, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glHistogramEXT, GLHISTOGRAMEXT, (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)) \
  FUNC(void, glMinmaxEXT, GLMINMAXEXT, (GLenum target, GLenum internalformat, GLboolean sink)) \
  FUNC(void, glResetHistogramEXT, GLRESETHISTOGRAMEXT, (GLenum target)) \
  FUNC(void, glResetMinmaxEXT, GLRESETMINMAXEXT, (GLenum target)) \
  CONST(GL_HISTOGRAM_EXT, 0x8024) \
  CONST(GL_PROXY_HISTOGRAM_EXT, 0x8025) \
  CONST(GL_HISTOGRAM_WIDTH_EXT, 0x8026) \
  CONST(GL_HISTOGRAM_FORMAT_EXT, 0x8027) \
  CONST(GL_HISTOGRAM_RED_SIZE_EXT, 0x8028) \
  CONST(GL_HISTOGRAM_GREEN_SIZE_EXT, 0x8029) \
  CONST(GL_HISTOGRAM_BLUE_SIZE_EXT, 0x802A) \
  CONST(GL_HISTOGRAM_ALPHA_SIZE_EXT, 0x802B) \
  CONST(GL_HISTOGRAM_LUMINANCE_SIZE_EXT, 0x802C) \
  CONST(GL_HISTOGRAM_SINK_EXT, 0x802D) \
  CONST(GL_MINMAX_EXT, 0x802E) \
  CONST(GL_MINMAX_FORMAT_EXT, 0x802F) \
  CONST(GL_MINMAX_SINK_EXT, 0x8030) \
  CONST(GL_TABLE_TOO_LARGE_EXT, 0x8031) \
  END()
#else
#define EXTENSION_GL_EXT_histogram(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_convolution
#define GL_EXT_convolution 1
#define EXTENSION_GL_EXT_convolution(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_convolution) \
  FUNC(void, glConvolutionFilter1DEXT, GLCONVOLUTIONFILTER1DEXT, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)) \
  FUNC(void, glConvolutionFilter2DEXT, GLCONVOLUTIONFILTER2DEXT, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)) \
  FUNC(void, glConvolutionParameterfEXT, GLCONVOLUTIONPARAMETERFEXT, (GLenum target, GLenum pname, GLfloat params)) \
  FUNC(void, glConvolutionParameterfvEXT, GLCONVOLUTIONPARAMETERFVEXT, (GLenum target, GLenum pname, const GLfloat * params)) \
  FUNC(void, glConvolutionParameteriEXT, GLCONVOLUTIONPARAMETERIEXT, (GLenum target, GLenum pname, GLint params)) \
  FUNC(void, glConvolutionParameterivEXT, GLCONVOLUTIONPARAMETERIVEXT, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glCopyConvolutionFilter1DEXT, GLCOPYCONVOLUTIONFILTER1DEXT, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
  FUNC(void, glCopyConvolutionFilter2DEXT, GLCOPYCONVOLUTIONFILTER2DEXT, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)) \
  FUNC(void, glGetConvolutionFilterEXT, GLGETCONVOLUTIONFILTEREXT, (GLenum target, GLenum format, GLenum type, GLvoid * image)) \
  FUNC(void, glGetConvolutionParameterfvEXT, GLGETCONVOLUTIONPARAMETERFVEXT, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetConvolutionParameterivEXT, GLGETCONVOLUTIONPARAMETERIVEXT, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetSeparableFilterEXT, GLGETSEPARABLEFILTEREXT, (GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)) \
  FUNC(void, glSeparableFilter2DEXT, GLSEPARABLEFILTER2DEXT, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)) \
  CONST(GL_CONVOLUTION_1D_EXT, 0x8010) \
  CONST(GL_CONVOLUTION_2D_EXT, 0x8011) \
  CONST(GL_SEPARABLE_2D_EXT, 0x8012) \
  CONST(GL_CONVOLUTION_BORDER_MODE_EXT, 0x8013) \
  CONST(GL_CONVOLUTION_FILTER_SCALE_EXT, 0x8014) \
  CONST(GL_CONVOLUTION_FILTER_BIAS_EXT, 0x8015) \
  CONST(GL_REDUCE_EXT, 0x8016) \
  CONST(GL_CONVOLUTION_FORMAT_EXT, 0x8017) \
  CONST(GL_CONVOLUTION_WIDTH_EXT, 0x8018) \
  CONST(GL_CONVOLUTION_HEIGHT_EXT, 0x8019) \
  CONST(GL_MAX_CONVOLUTION_WIDTH_EXT, 0x801A) \
  CONST(GL_MAX_CONVOLUTION_HEIGHT_EXT, 0x801B) \
  CONST(GL_POST_CONVOLUTION_RED_SCALE_EXT, 0x801C) \
  CONST(GL_POST_CONVOLUTION_GREEN_SCALE_EXT, 0x801D) \
  CONST(GL_POST_CONVOLUTION_BLUE_SCALE_EXT, 0x801E) \
  CONST(GL_POST_CONVOLUTION_ALPHA_SCALE_EXT, 0x801F) \
  CONST(GL_POST_CONVOLUTION_RED_BIAS_EXT, 0x8020) \
  CONST(GL_POST_CONVOLUTION_GREEN_BIAS_EXT, 0x8021) \
  CONST(GL_POST_CONVOLUTION_BLUE_BIAS_EXT, 0x8022) \
  CONST(GL_POST_CONVOLUTION_ALPHA_BIAS_EXT, 0x8023) \
  END()
#else
#define EXTENSION_GL_EXT_convolution(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGI_color_matrix
#define GL_SGI_color_matrix 1
#define EXTENSION_GL_SGI_color_matrix(NAME, FUNC, CONST, END) \
  NAME(GL_SGI_color_matrix) \
  CONST(GL_COLOR_MATRIX_SGI, 0x80B1) \
  CONST(GL_COLOR_MATRIX_STACK_DEPTH_SGI, 0x80B2) \
  CONST(GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI, 0x80B3) \
  CONST(GL_POST_COLOR_MATRIX_RED_SCALE_SGI, 0x80B4) \
  CONST(GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI, 0x80B5) \
  CONST(GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI, 0x80B6) \
  CONST(GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI, 0x80B7) \
  CONST(GL_POST_COLOR_MATRIX_RED_BIAS_SGI, 0x80B8) \
  CONST(GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI, 0x80B9) \
  CONST(GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI, 0x80BA) \
  CONST(GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI, 0x80BB) \
  END()
#else
#define EXTENSION_GL_SGI_color_matrix(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGI_color_table
#define GL_SGI_color_table 1
#define EXTENSION_GL_SGI_color_table(NAME, FUNC, CONST, END) \
  NAME(GL_SGI_color_table) \
  FUNC(void, glColorTableSGI, GLCOLORTABLESGI, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)) \
  FUNC(void, glColorTableParameterfvSGI, GLCOLORTABLEPARAMETERFVSGI, (GLenum target, GLenum pname, const GLfloat * params)) \
  FUNC(void, glColorTableParameterivSGI, GLCOLORTABLEPARAMETERIVSGI, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glCopyColorTableSGI, GLCOPYCOLORTABLESGI, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
  FUNC(void, glGetColorTableSGI, GLGETCOLORTABLESGI, (GLenum target, GLenum format, GLenum type, GLvoid * table)) \
  FUNC(void, glGetColorTableParameterfvSGI, GLGETCOLORTABLEPARAMETERFVSGI, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetColorTableParameterivSGI, GLGETCOLORTABLEPARAMETERIVSGI, (GLenum target, GLenum pname, GLint * params)) \
  CONST(GL_COLOR_TABLE_SGI, 0x80D0) \
  CONST(GL_POST_CONVOLUTION_COLOR_TABLE_SGI, 0x80D1) \
  CONST(GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI, 0x80D2) \
  CONST(GL_PROXY_COLOR_TABLE_SGI, 0x80D3) \
  CONST(GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, 0x80D4) \
  CONST(GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI, 0x80D5) \
  CONST(GL_COLOR_TABLE_SCALE_SGI, 0x80D6) \
  CONST(GL_COLOR_TABLE_BIAS_SGI, 0x80D7) \
  CONST(GL_COLOR_TABLE_FORMAT_SGI, 0x80D8) \
  CONST(GL_COLOR_TABLE_WIDTH_SGI, 0x80D9) \
  CONST(GL_COLOR_TABLE_RED_SIZE_SGI, 0x80DA) \
  CONST(GL_COLOR_TABLE_GREEN_SIZE_SGI, 0x80DB) \
  CONST(GL_COLOR_TABLE_BLUE_SIZE_SGI, 0x80DC) \
  CONST(GL_COLOR_TABLE_ALPHA_SIZE_SGI, 0x80DD) \
  CONST(GL_COLOR_TABLE_LUMINANCE_SIZE_SGI, 0x80DE) \
  CONST(GL_COLOR_TABLE_INTENSITY_SIZE_SGI, 0x80DF) \
  END()
#else
#define EXTENSION_GL_SGI_color_table(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_pixel_texture
#define GL_SGIS_pixel_texture 1
#define EXTENSION_GL_SGIS_pixel_texture(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_pixel_texture) \
  FUNC(void, glPixelTexGenParameteriSGIS, GLPIXELTEXGENPARAMETERISGIS, (GLenum pname, GLint param)) \
  FUNC(void, glPixelTexGenParameterivSGIS, GLPIXELTEXGENPARAMETERIVSGIS, (GLenum pname, const GLint * params)) \
  FUNC(void, glPixelTexGenParameterfSGIS, GLPIXELTEXGENPARAMETERFSGIS, (GLenum pname, GLfloat param)) \
  FUNC(void, glPixelTexGenParameterfvSGIS, GLPIXELTEXGENPARAMETERFVSGIS, (GLenum pname, const GLfloat * params)) \
  FUNC(void, glGetPixelTexGenParameterivSGIS, GLGETPIXELTEXGENPARAMETERIVSGIS, (GLenum pname, GLint * params)) \
  FUNC(void, glGetPixelTexGenParameterfvSGIS, GLGETPIXELTEXGENPARAMETERFVSGIS, (GLenum pname, GLfloat * params)) \
  CONST(GL_PIXEL_TEXTURE_SGIS, 0x8353) \
  CONST(GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS, 0x8354) \
  CONST(GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS, 0x8355) \
  CONST(GL_PIXEL_GROUP_COLOR_SGIS, 0x8356) \
  END()
#else
#define EXTENSION_GL_SGIS_pixel_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_pixel_texture
#define GL_SGIX_pixel_texture 1
#define EXTENSION_GL_SGIX_pixel_texture(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_pixel_texture) \
  FUNC(void, glPixelTexGenSGIX, GLPIXELTEXGENSGIX, (GLenum mode)) \
  CONST(GL_PIXEL_TEX_GEN_SGIX, 0x8139) \
  CONST(GL_PIXEL_TEX_GEN_MODE_SGIX, 0x832B) \
  END()
#else
#define EXTENSION_GL_SGIX_pixel_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_texture4D
#define GL_SGIS_texture4D 1
#define EXTENSION_GL_SGIS_texture4D(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_texture4D) \
  FUNC(void, glTexImage4DSGIS, GLTEXIMAGE4DSGIS, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid * pixels)) \
  FUNC(void, glTexSubImage4DSGIS, GLTEXSUBIMAGE4DSGIS, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid * pixels)) \
  CONST(GL_PACK_SKIP_VOLUMES_SGIS, 0x8130) \
  CONST(GL_PACK_IMAGE_DEPTH_SGIS, 0x8131) \
  CONST(GL_UNPACK_SKIP_VOLUMES_SGIS, 0x8132) \
  CONST(GL_UNPACK_IMAGE_DEPTH_SGIS, 0x8133) \
  CONST(GL_TEXTURE_4D_SGIS, 0x8134) \
  CONST(GL_PROXY_TEXTURE_4D_SGIS, 0x8135) \
  CONST(GL_TEXTURE_4DSIZE_SGIS, 0x8136) \
  CONST(GL_TEXTURE_WRAP_Q_SGIS, 0x8137) \
  CONST(GL_MAX_4D_TEXTURE_SIZE_SGIS, 0x8138) \
  CONST(GL_TEXTURE_4D_BINDING_SGIS, 0x814F) \
  END()
#else
#define EXTENSION_GL_SGIS_texture4D(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGI_texture_color_table
#define GL_SGI_texture_color_table 1
#define EXTENSION_GL_SGI_texture_color_table(NAME, FUNC, CONST, END) \
  NAME(GL_SGI_texture_color_table) \
  CONST(GL_TEXTURE_COLOR_TABLE_SGI, 0x80BC) \
  CONST(GL_PROXY_TEXTURE_COLOR_TABLE_SGI, 0x80BD) \
  END()
#else
#define EXTENSION_GL_SGI_texture_color_table(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_cmyka
#define GL_EXT_cmyka 1
#define EXTENSION_GL_EXT_cmyka(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_cmyka) \
  CONST(GL_CMYK_EXT, 0x800C) \
  CONST(GL_CMYKA_EXT, 0x800D) \
  CONST(GL_PACK_CMYK_HINT_EXT, 0x800E) \
  CONST(GL_UNPACK_CMYK_HINT_EXT, 0x800F) \
  END()
#else
#define EXTENSION_GL_EXT_cmyka(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_object
#define GL_EXT_texture_object 1
#define EXTENSION_GL_EXT_texture_object(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_object) \
  FUNC(GLboolean, glAreTexturesResidentEXT, GLARETEXTURESRESIDENTEXT, (GLsizei n, const GLuint * textures, GLboolean * residences)) \
  FUNC(void, glBindTextureEXT, GLBINDTEXTUREEXT, (GLenum target, GLuint texture)) \
  FUNC(void, glDeleteTexturesEXT, GLDELETETEXTURESEXT, (GLsizei n, const GLuint * textures)) \
  FUNC(void, glGenTexturesEXT, GLGENTEXTURESEXT, (GLsizei n, GLuint * textures)) \
  FUNC(GLboolean, glIsTextureEXT, GLISTEXTUREEXT, (GLuint texture)) \
  FUNC(void, glPrioritizeTexturesEXT, GLPRIORITIZETEXTURESEXT, (GLsizei n, const GLuint * textures, const GLclampf * priorities)) \
  CONST(GL_TEXTURE_PRIORITY_EXT, 0x8066) \
  CONST(GL_TEXTURE_RESIDENT_EXT, 0x8067) \
  CONST(GL_TEXTURE_1D_BINDING_EXT, 0x8068) \
  CONST(GL_TEXTURE_2D_BINDING_EXT, 0x8069) \
  CONST(GL_TEXTURE_3D_BINDING_EXT, 0x806A) \
  END()
#else
#define EXTENSION_GL_EXT_texture_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_detail_texture
#define GL_SGIS_detail_texture 1
#define EXTENSION_GL_SGIS_detail_texture(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_detail_texture) \
  FUNC(void, glDetailTexFuncSGIS, GLDETAILTEXFUNCSGIS, (GLenum target, GLsizei n, const GLfloat * points)) \
  FUNC(void, glGetDetailTexFuncSGIS, GLGETDETAILTEXFUNCSGIS, (GLenum target, GLfloat * points)) \
  CONST(GL_DETAIL_TEXTURE_2D_SGIS, 0x8095) \
  CONST(GL_DETAIL_TEXTURE_2D_BINDING_SGIS, 0x8096) \
  CONST(GL_LINEAR_DETAIL_SGIS, 0x8097) \
  CONST(GL_LINEAR_DETAIL_ALPHA_SGIS, 0x8098) \
  CONST(GL_LINEAR_DETAIL_COLOR_SGIS, 0x8099) \
  CONST(GL_DETAIL_TEXTURE_LEVEL_SGIS, 0x809A) \
  CONST(GL_DETAIL_TEXTURE_MODE_SGIS, 0x809B) \
  CONST(GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS, 0x809C) \
  END()
#else
#define EXTENSION_GL_SGIS_detail_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_sharpen_texture
#define GL_SGIS_sharpen_texture 1
#define EXTENSION_GL_SGIS_sharpen_texture(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_sharpen_texture) \
  FUNC(void, glSharpenTexFuncSGIS, GLSHARPENTEXFUNCSGIS, (GLenum target, GLsizei n, const GLfloat * points)) \
  FUNC(void, glGetSharpenTexFuncSGIS, GLGETSHARPENTEXFUNCSGIS, (GLenum target, GLfloat * points)) \
  CONST(GL_LINEAR_SHARPEN_SGIS, 0x80AD) \
  CONST(GL_LINEAR_SHARPEN_ALPHA_SGIS, 0x80AE) \
  CONST(GL_LINEAR_SHARPEN_COLOR_SGIS, 0x80AF) \
  CONST(GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS, 0x80B0) \
  END()
#else
#define EXTENSION_GL_SGIS_sharpen_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_packed_pixels
#define GL_EXT_packed_pixels 1
#define EXTENSION_GL_EXT_packed_pixels(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_packed_pixels) \
  CONST(GL_UNSIGNED_BYTE_3_3_2_EXT, 0x8032) \
  CONST(GL_UNSIGNED_SHORT_4_4_4_4_EXT, 0x8033) \
  CONST(GL_UNSIGNED_SHORT_5_5_5_1_EXT, 0x8034) \
  CONST(GL_UNSIGNED_INT_8_8_8_8_EXT, 0x8035) \
  CONST(GL_UNSIGNED_INT_10_10_10_2_EXT, 0x8036) \
  END()
#else
#define EXTENSION_GL_EXT_packed_pixels(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_texture_lod
#define GL_SGIS_texture_lod 1
#define EXTENSION_GL_SGIS_texture_lod(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_texture_lod) \
  CONST(GL_TEXTURE_MIN_LOD_SGIS, 0x813A) \
  CONST(GL_TEXTURE_MAX_LOD_SGIS, 0x813B) \
  CONST(GL_TEXTURE_BASE_LEVEL_SGIS, 0x813C) \
  CONST(GL_TEXTURE_MAX_LEVEL_SGIS, 0x813D) \
  END()
#else
#define EXTENSION_GL_SGIS_texture_lod(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_multisample
#define GL_SGIS_multisample 1
#define EXTENSION_GL_SGIS_multisample(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_multisample) \
  FUNC(void, glSampleMaskSGIS, GLSAMPLEMASKSGIS, (GLclampf value, GLboolean invert)) \
  FUNC(void, glSamplePatternSGIS, GLSAMPLEPATTERNSGIS, (GLenum pattern)) \
  CONST(GL_MULTISAMPLE_SGIS, 0x809D) \
  CONST(GL_SAMPLE_ALPHA_TO_MASK_SGIS, 0x809E) \
  CONST(GL_SAMPLE_ALPHA_TO_ONE_SGIS, 0x809F) \
  CONST(GL_SAMPLE_MASK_SGIS, 0x80A0) \
  CONST(GL_1PASS_SGIS, 0x80A1) \
  CONST(GL_2PASS_0_SGIS, 0x80A2) \
  CONST(GL_2PASS_1_SGIS, 0x80A3) \
  CONST(GL_4PASS_0_SGIS, 0x80A4) \
  CONST(GL_4PASS_1_SGIS, 0x80A5) \
  CONST(GL_4PASS_2_SGIS, 0x80A6) \
  CONST(GL_4PASS_3_SGIS, 0x80A7) \
  CONST(GL_SAMPLE_BUFFERS_SGIS, 0x80A8) \
  CONST(GL_SAMPLES_SGIS, 0x80A9) \
  CONST(GL_SAMPLE_MASK_VALUE_SGIS, 0x80AA) \
  CONST(GL_SAMPLE_MASK_INVERT_SGIS, 0x80AB) \
  CONST(GL_SAMPLE_PATTERN_SGIS, 0x80AC) \
  END()
#else
#define EXTENSION_GL_SGIS_multisample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_rescale_normal
#define GL_EXT_rescale_normal 1
#define EXTENSION_GL_EXT_rescale_normal(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_rescale_normal) \
  CONST(GL_RESCALE_NORMAL_EXT, 0x803A) \
  END()
#else
#define EXTENSION_GL_EXT_rescale_normal(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_vertex_array
#define GL_EXT_vertex_array 1
#define EXTENSION_GL_EXT_vertex_array(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_vertex_array) \
  FUNC(void, glArrayElementEXT, GLARRAYELEMENTEXT, (GLint i)) \
  FUNC(void, glColorPointerEXT, GLCOLORPOINTEREXT, (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)) \
  FUNC(void, glDrawArraysEXT, GLDRAWARRAYSEXT, (GLenum mode, GLint first, GLsizei count)) \
  FUNC(void, glEdgeFlagPointerEXT, GLEDGEFLAGPOINTEREXT, (GLsizei stride, GLsizei count, const GLboolean * pointer)) \
  FUNC(void, glGetPointervEXT, GLGETPOINTERVEXT, (GLenum pname, GLvoid* * params)) \
  FUNC(void, glIndexPointerEXT, GLINDEXPOINTEREXT, (GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)) \
  FUNC(void, glNormalPointerEXT, GLNORMALPOINTEREXT, (GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)) \
  FUNC(void, glTexCoordPointerEXT, GLTEXCOORDPOINTEREXT, (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)) \
  FUNC(void, glVertexPointerEXT, GLVERTEXPOINTEREXT, (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)) \
  CONST(GL_VERTEX_ARRAY_EXT, 0x8074) \
  CONST(GL_NORMAL_ARRAY_EXT, 0x8075) \
  CONST(GL_COLOR_ARRAY_EXT, 0x8076) \
  CONST(GL_INDEX_ARRAY_EXT, 0x8077) \
  CONST(GL_TEXTURE_COORD_ARRAY_EXT, 0x8078) \
  CONST(GL_EDGE_FLAG_ARRAY_EXT, 0x8079) \
  CONST(GL_VERTEX_ARRAY_SIZE_EXT, 0x807A) \
  CONST(GL_VERTEX_ARRAY_TYPE_EXT, 0x807B) \
  CONST(GL_VERTEX_ARRAY_STRIDE_EXT, 0x807C) \
  CONST(GL_VERTEX_ARRAY_COUNT_EXT, 0x807D) \
  CONST(GL_NORMAL_ARRAY_TYPE_EXT, 0x807E) \
  CONST(GL_NORMAL_ARRAY_STRIDE_EXT, 0x807F) \
  CONST(GL_NORMAL_ARRAY_COUNT_EXT, 0x8080) \
  CONST(GL_COLOR_ARRAY_SIZE_EXT, 0x8081) \
  CONST(GL_COLOR_ARRAY_TYPE_EXT, 0x8082) \
  CONST(GL_COLOR_ARRAY_STRIDE_EXT, 0x8083) \
  CONST(GL_COLOR_ARRAY_COUNT_EXT, 0x8084) \
  CONST(GL_INDEX_ARRAY_TYPE_EXT, 0x8085) \
  CONST(GL_INDEX_ARRAY_STRIDE_EXT, 0x8086) \
  CONST(GL_INDEX_ARRAY_COUNT_EXT, 0x8087) \
  CONST(GL_TEXTURE_COORD_ARRAY_SIZE_EXT, 0x8088) \
  CONST(GL_TEXTURE_COORD_ARRAY_TYPE_EXT, 0x8089) \
  CONST(GL_TEXTURE_COORD_ARRAY_STRIDE_EXT, 0x808A) \
  CONST(GL_TEXTURE_COORD_ARRAY_COUNT_EXT, 0x808B) \
  CONST(GL_EDGE_FLAG_ARRAY_STRIDE_EXT, 0x808C) \
  CONST(GL_EDGE_FLAG_ARRAY_COUNT_EXT, 0x808D) \
  CONST(GL_VERTEX_ARRAY_POINTER_EXT, 0x808E) \
  CONST(GL_NORMAL_ARRAY_POINTER_EXT, 0x808F) \
  CONST(GL_COLOR_ARRAY_POINTER_EXT, 0x8090) \
  CONST(GL_INDEX_ARRAY_POINTER_EXT, 0x8091) \
  CONST(GL_TEXTURE_COORD_ARRAY_POINTER_EXT, 0x8092) \
  CONST(GL_EDGE_FLAG_ARRAY_POINTER_EXT, 0x8093) \
  END()
#else
#define EXTENSION_GL_EXT_vertex_array(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_misc_attribute
#define GL_EXT_misc_attribute 1
#define EXTENSION_GL_EXT_misc_attribute(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_misc_attribute) \
  END()
#else
#define EXTENSION_GL_EXT_misc_attribute(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_generate_mipmap
#define GL_SGIS_generate_mipmap 1
#define EXTENSION_GL_SGIS_generate_mipmap(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_generate_mipmap) \
  CONST(GL_GENERATE_MIPMAP_SGIS, 0x8191) \
  CONST(GL_GENERATE_MIPMAP_HINT_SGIS, 0x8192) \
  END()
#else
#define EXTENSION_GL_SGIS_generate_mipmap(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_clipmap
#define GL_SGIX_clipmap 1
#define EXTENSION_GL_SGIX_clipmap(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_clipmap) \
  CONST(GL_LINEAR_CLIPMAP_LINEAR_SGIX, 0x8170) \
  CONST(GL_TEXTURE_CLIPMAP_CENTER_SGIX, 0x8171) \
  CONST(GL_TEXTURE_CLIPMAP_FRAME_SGIX, 0x8172) \
  CONST(GL_TEXTURE_CLIPMAP_OFFSET_SGIX, 0x8173) \
  CONST(GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX, 0x8174) \
  CONST(GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX, 0x8175) \
  CONST(GL_TEXTURE_CLIPMAP_DEPTH_SGIX, 0x8176) \
  CONST(GL_MAX_CLIPMAP_DEPTH_SGIX, 0x8177) \
  CONST(GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX, 0x8178) \
  CONST(GL_NEAREST_CLIPMAP_NEAREST_SGIX, 0x844D) \
  CONST(GL_NEAREST_CLIPMAP_LINEAR_SGIX, 0x844E) \
  CONST(GL_LINEAR_CLIPMAP_NEAREST_SGIX, 0x844F) \
  END()
#else
#define EXTENSION_GL_SGIX_clipmap(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_shadow
#define GL_SGIX_shadow 1
#define EXTENSION_GL_SGIX_shadow(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_shadow) \
  CONST(GL_TEXTURE_COMPARE_SGIX, 0x819A) \
  CONST(GL_TEXTURE_COMPARE_OPERATOR_SGIX, 0x819B) \
  CONST(GL_TEXTURE_LEQUAL_R_SGIX, 0x819C) \
  CONST(GL_TEXTURE_GEQUAL_R_SGIX, 0x819D) \
  END()
#else
#define EXTENSION_GL_SGIX_shadow(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_texture_edge_clamp
#define GL_SGIS_texture_edge_clamp 1
#define EXTENSION_GL_SGIS_texture_edge_clamp(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_texture_edge_clamp) \
  CONST(GL_CLAMP_TO_EDGE_SGIS, 0x812F) \
  END()
#else
#define EXTENSION_GL_SGIS_texture_edge_clamp(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_texture_border_clamp
#define GL_SGIS_texture_border_clamp 1
#define EXTENSION_GL_SGIS_texture_border_clamp(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_texture_border_clamp) \
  CONST(GL_CLAMP_TO_BORDER_SGIS, 0x812D) \
  END()
#else
#define EXTENSION_GL_SGIS_texture_border_clamp(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_blend_minmax
#define GL_EXT_blend_minmax 1
#define EXTENSION_GL_EXT_blend_minmax(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_blend_minmax) \
  FUNC(void, glBlendEquationEXT, GLBLENDEQUATIONEXT, (GLenum mode)) \
  CONST(GL_FUNC_ADD_EXT, 0x8006) \
  CONST(GL_MIN_EXT, 0x8007) \
  CONST(GL_MAX_EXT, 0x8008) \
  CONST(GL_BLEND_EQUATION_EXT, 0x8009) \
  END()
#else
#define EXTENSION_GL_EXT_blend_minmax(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_blend_subtract
#define GL_EXT_blend_subtract 1
#define EXTENSION_GL_EXT_blend_subtract(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_blend_subtract) \
  CONST(GL_FUNC_SUBTRACT_EXT, 0x800A) \
  CONST(GL_FUNC_REVERSE_SUBTRACT_EXT, 0x800B) \
  END()
#else
#define EXTENSION_GL_EXT_blend_subtract(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_blend_logic_op
#define GL_EXT_blend_logic_op 1
#define EXTENSION_GL_EXT_blend_logic_op(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_blend_logic_op) \
  END()
#else
#define EXTENSION_GL_EXT_blend_logic_op(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_interlace
#define GL_SGIX_interlace 1
#define EXTENSION_GL_SGIX_interlace(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_interlace) \
  CONST(GL_INTERLACE_SGIX, 0x8094) \
  END()
#else
#define EXTENSION_GL_SGIX_interlace(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_pixel_tiles
#define GL_SGIX_pixel_tiles 1
#define EXTENSION_GL_SGIX_pixel_tiles(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_pixel_tiles) \
  CONST(GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX, 0x813E) \
  CONST(GL_PIXEL_TILE_CACHE_INCREMENT_SGIX, 0x813F) \
  CONST(GL_PIXEL_TILE_WIDTH_SGIX, 0x8140) \
  CONST(GL_PIXEL_TILE_HEIGHT_SGIX, 0x8141) \
  CONST(GL_PIXEL_TILE_GRID_WIDTH_SGIX, 0x8142) \
  CONST(GL_PIXEL_TILE_GRID_HEIGHT_SGIX, 0x8143) \
  CONST(GL_PIXEL_TILE_GRID_DEPTH_SGIX, 0x8144) \
  CONST(GL_PIXEL_TILE_CACHE_SIZE_SGIX, 0x8145) \
  END()
#else
#define EXTENSION_GL_SGIX_pixel_tiles(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_texture_select
#define GL_SGIS_texture_select 1
#define EXTENSION_GL_SGIS_texture_select(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_texture_select) \
  CONST(GL_DUAL_ALPHA4_SGIS, 0x8110) \
  CONST(GL_DUAL_ALPHA8_SGIS, 0x8111) \
  CONST(GL_DUAL_ALPHA12_SGIS, 0x8112) \
  CONST(GL_DUAL_ALPHA16_SGIS, 0x8113) \
  CONST(GL_DUAL_LUMINANCE4_SGIS, 0x8114) \
  CONST(GL_DUAL_LUMINANCE8_SGIS, 0x8115) \
  CONST(GL_DUAL_LUMINANCE12_SGIS, 0x8116) \
  CONST(GL_DUAL_LUMINANCE16_SGIS, 0x8117) \
  CONST(GL_DUAL_INTENSITY4_SGIS, 0x8118) \
  CONST(GL_DUAL_INTENSITY8_SGIS, 0x8119) \
  CONST(GL_DUAL_INTENSITY12_SGIS, 0x811A) \
  CONST(GL_DUAL_INTENSITY16_SGIS, 0x811B) \
  CONST(GL_DUAL_LUMINANCE_ALPHA4_SGIS, 0x811C) \
  CONST(GL_DUAL_LUMINANCE_ALPHA8_SGIS, 0x811D) \
  CONST(GL_QUAD_ALPHA4_SGIS, 0x811E) \
  CONST(GL_QUAD_ALPHA8_SGIS, 0x811F) \
  CONST(GL_QUAD_LUMINANCE4_SGIS, 0x8120) \
  CONST(GL_QUAD_LUMINANCE8_SGIS, 0x8121) \
  CONST(GL_QUAD_INTENSITY4_SGIS, 0x8122) \
  CONST(GL_QUAD_INTENSITY8_SGIS, 0x8123) \
  CONST(GL_DUAL_TEXTURE_SELECT_SGIS, 0x8124) \
  CONST(GL_QUAD_TEXTURE_SELECT_SGIS, 0x8125) \
  END()
#else
#define EXTENSION_GL_SGIS_texture_select(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_sprite
#define GL_SGIX_sprite 1
#define EXTENSION_GL_SGIX_sprite(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_sprite) \
  FUNC(void, glSpriteParameterfSGIX, GLSPRITEPARAMETERFSGIX, (GLenum pname, GLfloat param)) \
  FUNC(void, glSpriteParameterfvSGIX, GLSPRITEPARAMETERFVSGIX, (GLenum pname, const GLfloat * params)) \
  FUNC(void, glSpriteParameteriSGIX, GLSPRITEPARAMETERISGIX, (GLenum pname, GLint param)) \
  FUNC(void, glSpriteParameterivSGIX, GLSPRITEPARAMETERIVSGIX, (GLenum pname, const GLint * params)) \
  CONST(GL_SPRITE_SGIX, 0x8148) \
  CONST(GL_SPRITE_MODE_SGIX, 0x8149) \
  CONST(GL_SPRITE_AXIS_SGIX, 0x814A) \
  CONST(GL_SPRITE_TRANSLATION_SGIX, 0x814B) \
  CONST(GL_SPRITE_AXIAL_SGIX, 0x814C) \
  CONST(GL_SPRITE_OBJECT_ALIGNED_SGIX, 0x814D) \
  CONST(GL_SPRITE_EYE_ALIGNED_SGIX, 0x814E) \
  END()
#else
#define EXTENSION_GL_SGIX_sprite(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_texture_multi_buffer
#define GL_SGIX_texture_multi_buffer 1
#define EXTENSION_GL_SGIX_texture_multi_buffer(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_texture_multi_buffer) \
  CONST(GL_TEXTURE_MULTI_BUFFER_HINT_SGIX, 0x812E) \
  END()
#else
#define EXTENSION_GL_SGIX_texture_multi_buffer(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_point_parameters
#define GL_EXT_point_parameters 1
#define EXTENSION_GL_EXT_point_parameters(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_point_parameters) \
  FUNC(void, glPointParameterfEXT, GLPOINTPARAMETERFEXT, (GLenum pname, GLfloat param)) \
  FUNC(void, glPointParameterfvEXT, GLPOINTPARAMETERFVEXT, (GLenum pname, const GLfloat * params)) \
  CONST(GL_POINT_SIZE_MIN_EXT, 0x8126) \
  CONST(GL_POINT_SIZE_MAX_EXT, 0x8127) \
  CONST(GL_POINT_FADE_THRESHOLD_SIZE_EXT, 0x8128) \
  CONST(GL_DISTANCE_ATTENUATION_EXT, 0x8129) \
  END()
#else
#define EXTENSION_GL_EXT_point_parameters(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_point_parameters
#define GL_SGIS_point_parameters 1
#define EXTENSION_GL_SGIS_point_parameters(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_point_parameters) \
  FUNC(void, glPointParameterfSGIS, GLPOINTPARAMETERFSGIS, (GLenum pname, GLfloat param)) \
  FUNC(void, glPointParameterfvSGIS, GLPOINTPARAMETERFVSGIS, (GLenum pname, const GLfloat * params)) \
  CONST(GL_POINT_SIZE_MIN_SGIS, 0x8126) \
  CONST(GL_POINT_SIZE_MAX_SGIS, 0x8127) \
  CONST(GL_POINT_FADE_THRESHOLD_SIZE_SGIS, 0x8128) \
  CONST(GL_DISTANCE_ATTENUATION_SGIS, 0x8129) \
  END()
#else
#define EXTENSION_GL_SGIS_point_parameters(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_instruments
#define GL_SGIX_instruments 1
#define EXTENSION_GL_SGIX_instruments(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_instruments) \
  FUNC(GLint, glGetInstrumentsSGIX, GLGETINSTRUMENTSSGIX, ()) \
  FUNC(void, glInstrumentsBufferSGIX, GLINSTRUMENTSBUFFERSGIX, (GLsizei size, GLint * buffer)) \
  FUNC(GLint, glPollInstrumentsSGIX, GLPOLLINSTRUMENTSSGIX, (GLint * marker_p)) \
  FUNC(void, glReadInstrumentsSGIX, GLREADINSTRUMENTSSGIX, (GLint marker)) \
  FUNC(void, glStartInstrumentsSGIX, GLSTARTINSTRUMENTSSGIX, ()) \
  FUNC(void, glStopInstrumentsSGIX, GLSTOPINSTRUMENTSSGIX, (GLint marker)) \
  CONST(GL_INSTRUMENT_BUFFER_POINTER_SGIX, 0x8180) \
  CONST(GL_INSTRUMENT_MEASUREMENTS_SGIX, 0x8181) \
  END()
#else
#define EXTENSION_GL_SGIX_instruments(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_texture_scale_bias
#define GL_SGIX_texture_scale_bias 1
#define EXTENSION_GL_SGIX_texture_scale_bias(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_texture_scale_bias) \
  CONST(GL_POST_TEXTURE_FILTER_BIAS_SGIX, 0x8179) \
  CONST(GL_POST_TEXTURE_FILTER_SCALE_SGIX, 0x817A) \
  CONST(GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX, 0x817B) \
  CONST(GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX, 0x817C) \
  END()
#else
#define EXTENSION_GL_SGIX_texture_scale_bias(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_framezoom
#define GL_SGIX_framezoom 1
#define EXTENSION_GL_SGIX_framezoom(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_framezoom) \
  FUNC(void, glFrameZoomSGIX, GLFRAMEZOOMSGIX, (GLint factor)) \
  CONST(GL_FRAMEZOOM_SGIX, 0x818B) \
  CONST(GL_FRAMEZOOM_FACTOR_SGIX, 0x818C) \
  CONST(GL_MAX_FRAMEZOOM_FACTOR_SGIX, 0x818D) \
  END()
#else
#define EXTENSION_GL_SGIX_framezoom(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_tag_sample_buffer
#define GL_SGIX_tag_sample_buffer 1
#define EXTENSION_GL_SGIX_tag_sample_buffer(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_tag_sample_buffer) \
  FUNC(void, glTagSampleBufferSGIX, GLTAGSAMPLEBUFFERSGIX, ()) \
  END()
#else
#define EXTENSION_GL_SGIX_tag_sample_buffer(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_FfdMaskSGIX
#define GL_FfdMaskSGIX 1
#define EXTENSION_GL_FfdMaskSGIX(NAME, FUNC, CONST, END) \
  NAME(GL_FfdMaskSGIX) \
  CONST(GL_TEXTURE_DEFORMATION_BIT_SGIX, 0x00000001) \
  CONST(GL_GEOMETRY_DEFORMATION_BIT_SGIX, 0x00000002) \
  END()
#else
#define EXTENSION_GL_FfdMaskSGIX(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_polynomial_ffd
#define GL_SGIX_polynomial_ffd 1
#define EXTENSION_GL_SGIX_polynomial_ffd(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_polynomial_ffd) \
  FUNC(void, glDeformationMap3dSGIX, GLDEFORMATIONMAP3DSGIX, (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble * points)) \
  FUNC(void, glDeformationMap3fSGIX, GLDEFORMATIONMAP3FSGIX, (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat * points)) \
  FUNC(void, glDeformSGIX, GLDEFORMSGIX, (GLbitfield mask)) \
  FUNC(void, glLoadIdentityDeformationMapSGIX, GLLOADIDENTITYDEFORMATIONMAPSGIX, (GLbitfield mask)) \
  CONST(GL_GEOMETRY_DEFORMATION_SGIX, 0x8194) \
  CONST(GL_TEXTURE_DEFORMATION_SGIX, 0x8195) \
  CONST(GL_DEFORMATIONS_MASK_SGIX, 0x8196) \
  CONST(GL_MAX_DEFORMATION_ORDER_SGIX, 0x8197) \
  END()
#else
#define EXTENSION_GL_SGIX_polynomial_ffd(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_reference_plane
#define GL_SGIX_reference_plane 1
#define EXTENSION_GL_SGIX_reference_plane(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_reference_plane) \
  FUNC(void, glReferencePlaneSGIX, GLREFERENCEPLANESGIX, (const GLdouble * equation)) \
  CONST(GL_REFERENCE_PLANE_SGIX, 0x817D) \
  CONST(GL_REFERENCE_PLANE_EQUATION_SGIX, 0x817E) \
  END()
#else
#define EXTENSION_GL_SGIX_reference_plane(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_flush_raster
#define GL_SGIX_flush_raster 1
#define EXTENSION_GL_SGIX_flush_raster(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_flush_raster) \
  FUNC(void, glFlushRasterSGIX, GLFLUSHRASTERSGIX, ()) \
  END()
#else
#define EXTENSION_GL_SGIX_flush_raster(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_depth_texture
#define GL_SGIX_depth_texture 1
#define EXTENSION_GL_SGIX_depth_texture(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_depth_texture) \
  CONST(GL_DEPTH_COMPONENT16_SGIX, 0x81A5) \
  CONST(GL_DEPTH_COMPONENT24_SGIX, 0x81A6) \
  CONST(GL_DEPTH_COMPONENT32_SGIX, 0x81A7) \
  END()
#else
#define EXTENSION_GL_SGIX_depth_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_fog_function
#define GL_SGIS_fog_function 1
#define EXTENSION_GL_SGIS_fog_function(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_fog_function) \
  FUNC(void, glFogFuncSGIS, GLFOGFUNCSGIS, (GLsizei n, const GLfloat * points)) \
  FUNC(void, glGetFogFuncSGIS, GLGETFOGFUNCSGIS, (GLfloat * points)) \
  CONST(GL_FOG_FUNC_SGIS, 0x812A) \
  CONST(GL_FOG_FUNC_POINTS_SGIS, 0x812B) \
  CONST(GL_MAX_FOG_FUNC_POINTS_SGIS, 0x812C) \
  END()
#else
#define EXTENSION_GL_SGIS_fog_function(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_fog_offset
#define GL_SGIX_fog_offset 1
#define EXTENSION_GL_SGIX_fog_offset(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_fog_offset) \
  CONST(GL_FOG_OFFSET_SGIX, 0x8198) \
  CONST(GL_FOG_OFFSET_VALUE_SGIX, 0x8199) \
  END()
#else
#define EXTENSION_GL_SGIX_fog_offset(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_HP_image_transform
#define GL_HP_image_transform 1
#define EXTENSION_GL_HP_image_transform(NAME, FUNC, CONST, END) \
  NAME(GL_HP_image_transform) \
  FUNC(void, glImageTransformParameteriHP, GLIMAGETRANSFORMPARAMETERIHP, (GLenum target, GLenum pname, GLint param)) \
  FUNC(void, glImageTransformParameterfHP, GLIMAGETRANSFORMPARAMETERFHP, (GLenum target, GLenum pname, GLfloat param)) \
  FUNC(void, glImageTransformParameterivHP, GLIMAGETRANSFORMPARAMETERIVHP, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glImageTransformParameterfvHP, GLIMAGETRANSFORMPARAMETERFVHP, (GLenum target, GLenum pname, const GLfloat * params)) \
  FUNC(void, glGetImageTransformParameterivHP, GLGETIMAGETRANSFORMPARAMETERIVHP, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetImageTransformParameterfvHP, GLGETIMAGETRANSFORMPARAMETERFVHP, (GLenum target, GLenum pname, GLfloat * params)) \
  CONST(GL_IMAGE_SCALE_X_HP, 0x8155) \
  CONST(GL_IMAGE_SCALE_Y_HP, 0x8156) \
  CONST(GL_IMAGE_TRANSLATE_X_HP, 0x8157) \
  CONST(GL_IMAGE_TRANSLATE_Y_HP, 0x8158) \
  CONST(GL_IMAGE_ROTATE_ANGLE_HP, 0x8159) \
  CONST(GL_IMAGE_ROTATE_ORIGIN_X_HP, 0x815A) \
  CONST(GL_IMAGE_ROTATE_ORIGIN_Y_HP, 0x815B) \
  CONST(GL_IMAGE_MAG_FILTER_HP, 0x815C) \
  CONST(GL_IMAGE_MIN_FILTER_HP, 0x815D) \
  CONST(GL_IMAGE_CUBIC_WEIGHT_HP, 0x815E) \
  CONST(GL_CUBIC_HP, 0x815F) \
  CONST(GL_AVERAGE_HP, 0x8160) \
  CONST(GL_IMAGE_TRANSFORM_2D_HP, 0x8161) \
  CONST(GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP, 0x8162) \
  CONST(GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP, 0x8163) \
  END()
#else
#define EXTENSION_GL_HP_image_transform(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_HP_convolution_border_modes
#define GL_HP_convolution_border_modes 1
#define EXTENSION_GL_HP_convolution_border_modes(NAME, FUNC, CONST, END) \
  NAME(GL_HP_convolution_border_modes) \
  CONST(GL_IGNORE_BORDER_HP, 0x8150) \
  CONST(GL_CONSTANT_BORDER_HP, 0x8151) \
  CONST(GL_REPLICATE_BORDER_HP, 0x8153) \
  CONST(GL_CONVOLUTION_BORDER_COLOR_HP, 0x8154) \
  END()
#else
#define EXTENSION_GL_HP_convolution_border_modes(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_INGR_palette_buffer
#define GL_INGR_palette_buffer 1
#define EXTENSION_GL_INGR_palette_buffer(NAME, FUNC, CONST, END) \
  NAME(GL_INGR_palette_buffer) \
  END()
#else
#define EXTENSION_GL_INGR_palette_buffer(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_texture_add_env
#define GL_SGIX_texture_add_env 1
#define EXTENSION_GL_SGIX_texture_add_env(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_texture_add_env) \
  CONST(GL_TEXTURE_ENV_BIAS_SGIX, 0x80BE) \
  END()
#else
#define EXTENSION_GL_SGIX_texture_add_env(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_color_subtable
#define GL_EXT_color_subtable 1
#define EXTENSION_GL_EXT_color_subtable(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_color_subtable) \
  FUNC(void, glColorSubTableEXT, GLCOLORSUBTABLEEXT, (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)) \
  FUNC(void, glCopyColorSubTableEXT, GLCOPYCOLORSUBTABLEEXT, (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)) \
  END()
#else
#define EXTENSION_GL_EXT_color_subtable(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_PGI_vertex_hints
#define GL_PGI_vertex_hints 1
#define EXTENSION_GL_PGI_vertex_hints(NAME, FUNC, CONST, END) \
  NAME(GL_PGI_vertex_hints) \
  CONST(GL_VERTEX_DATA_HINT_PGI, 0x1A22A) \
  CONST(GL_VERTEX_CONSISTENT_HINT_PGI, 0x1A22B) \
  CONST(GL_MATERIAL_SIDE_HINT_PGI, 0x1A22C) \
  CONST(GL_MAX_VERTEX_HINT_PGI, 0x1A22D) \
  CONST(GL_COLOR3_BIT_PGI, 0x00010000) \
  CONST(GL_COLOR4_BIT_PGI, 0x00020000) \
  CONST(GL_EDGEFLAG_BIT_PGI, 0x00040000) \
  CONST(GL_INDEX_BIT_PGI, 0x00080000) \
  CONST(GL_MAT_AMBIENT_BIT_PGI, 0x00100000) \
  CONST(GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI, 0x00200000) \
  CONST(GL_MAT_DIFFUSE_BIT_PGI, 0x00400000) \
  CONST(GL_MAT_EMISSION_BIT_PGI, 0x00800000) \
  CONST(GL_MAT_COLOR_INDEXES_BIT_PGI, 0x01000000) \
  CONST(GL_MAT_SHININESS_BIT_PGI, 0x02000000) \
  CONST(GL_MAT_SPECULAR_BIT_PGI, 0x04000000) \
  CONST(GL_NORMAL_BIT_PGI, 0x08000000) \
  CONST(GL_TEXCOORD1_BIT_PGI, 0x10000000) \
  CONST(GL_TEXCOORD2_BIT_PGI, 0x20000000) \
  CONST(GL_TEXCOORD3_BIT_PGI, 0x40000000) \
  CONST(GL_TEXCOORD4_BIT_PGI, 0x80000000) \
  CONST(GL_VERTEX23_BIT_PGI, 0x00000004) \
  CONST(GL_VERTEX4_BIT_PGI, 0x00000008) \
  END()
#else
#define EXTENSION_GL_PGI_vertex_hints(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_PGI_misc_hints
#define GL_PGI_misc_hints 1
#define EXTENSION_GL_PGI_misc_hints(NAME, FUNC, CONST, END) \
  NAME(GL_PGI_misc_hints) \
  FUNC(void, glHintPGI, GLHINTPGI, (GLenum target, GLint mode)) \
  CONST(GL_PREFER_DOUBLEBUFFER_HINT_PGI, 0x1A1F8) \
  CONST(GL_CONSERVE_MEMORY_HINT_PGI, 0x1A1FD) \
  CONST(GL_RECLAIM_MEMORY_HINT_PGI, 0x1A1FE) \
  CONST(GL_NATIVE_GRAPHICS_HANDLE_PGI, 0x1A202) \
  CONST(GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI, 0x1A203) \
  CONST(GL_NATIVE_GRAPHICS_END_HINT_PGI, 0x1A204) \
  CONST(GL_ALWAYS_FAST_HINT_PGI, 0x1A20C) \
  CONST(GL_ALWAYS_SOFT_HINT_PGI, 0x1A20D) \
  CONST(GL_ALLOW_DRAW_OBJ_HINT_PGI, 0x1A20E) \
  CONST(GL_ALLOW_DRAW_WIN_HINT_PGI, 0x1A20F) \
  CONST(GL_ALLOW_DRAW_FRG_HINT_PGI, 0x1A210) \
  CONST(GL_ALLOW_DRAW_MEM_HINT_PGI, 0x1A211) \
  CONST(GL_STRICT_DEPTHFUNC_HINT_PGI, 0x1A216) \
  CONST(GL_STRICT_LIGHTING_HINT_PGI, 0x1A217) \
  CONST(GL_STRICT_SCISSOR_HINT_PGI, 0x1A218) \
  CONST(GL_FULL_STIPPLE_HINT_PGI, 0x1A219) \
  CONST(GL_CLIP_NEAR_HINT_PGI, 0x1A220) \
  CONST(GL_CLIP_FAR_HINT_PGI, 0x1A221) \
  CONST(GL_WIDE_LINE_HINT_PGI, 0x1A222) \
  CONST(GL_BACK_NORMALS_HINT_PGI, 0x1A223) \
  END()
#else
#define EXTENSION_GL_PGI_misc_hints(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_paletted_texture
#define GL_EXT_paletted_texture 1
#define EXTENSION_GL_EXT_paletted_texture(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_paletted_texture) \
  FUNC(void, glColorTableEXT, GLCOLORTABLEEXT, (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)) \
  FUNC(void, glGetColorTableEXT, GLGETCOLORTABLEEXT, (GLenum target, GLenum format, GLenum type, GLvoid * data)) \
  FUNC(void, glGetColorTableParameterivEXT, GLGETCOLORTABLEPARAMETERIVEXT, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetColorTableParameterfvEXT, GLGETCOLORTABLEPARAMETERFVEXT, (GLenum target, GLenum pname, GLfloat * params)) \
  CONST(GL_COLOR_INDEX1_EXT, 0x80E2) \
  CONST(GL_COLOR_INDEX2_EXT, 0x80E3) \
  CONST(GL_COLOR_INDEX4_EXT, 0x80E4) \
  CONST(GL_COLOR_INDEX8_EXT, 0x80E5) \
  CONST(GL_COLOR_INDEX12_EXT, 0x80E6) \
  CONST(GL_COLOR_INDEX16_EXT, 0x80E7) \
  CONST(GL_TEXTURE_INDEX_SIZE_EXT, 0x80ED) \
  END()
#else
#define EXTENSION_GL_EXT_paletted_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_clip_volume_hint
#define GL_EXT_clip_volume_hint 1
#define EXTENSION_GL_EXT_clip_volume_hint(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_clip_volume_hint) \
  CONST(GL_CLIP_VOLUME_CLIPPING_HINT_EXT, 0x80F0) \
  END()
#else
#define EXTENSION_GL_EXT_clip_volume_hint(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_list_priority
#define GL_SGIX_list_priority 1
#define EXTENSION_GL_SGIX_list_priority(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_list_priority) \
  FUNC(void, glGetListParameterfvSGIX, GLGETLISTPARAMETERFVSGIX, (GLuint list, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetListParameterivSGIX, GLGETLISTPARAMETERIVSGIX, (GLuint list, GLenum pname, GLint * params)) \
  FUNC(void, glListParameterfSGIX, GLLISTPARAMETERFSGIX, (GLuint list, GLenum pname, GLfloat param)) \
  FUNC(void, glListParameterfvSGIX, GLLISTPARAMETERFVSGIX, (GLuint list, GLenum pname, const GLfloat * params)) \
  FUNC(void, glListParameteriSGIX, GLLISTPARAMETERISGIX, (GLuint list, GLenum pname, GLint param)) \
  FUNC(void, glListParameterivSGIX, GLLISTPARAMETERIVSGIX, (GLuint list, GLenum pname, const GLint * params)) \
  CONST(GL_LIST_PRIORITY_SGIX, 0x8182) \
  END()
#else
#define EXTENSION_GL_SGIX_list_priority(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_ir_instrument1
#define GL_SGIX_ir_instrument1 1
#define EXTENSION_GL_SGIX_ir_instrument1(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_ir_instrument1) \
  CONST(GL_IR_INSTRUMENT1_SGIX, 0x817F) \
  END()
#else
#define EXTENSION_GL_SGIX_ir_instrument1(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_calligraphic_fragment
#define GL_SGIX_calligraphic_fragment 1
#define EXTENSION_GL_SGIX_calligraphic_fragment(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_calligraphic_fragment) \
  CONST(GL_CALLIGRAPHIC_FRAGMENT_SGIX, 0x8183) \
  END()
#else
#define EXTENSION_GL_SGIX_calligraphic_fragment(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_texture_lod_bias
#define GL_SGIX_texture_lod_bias 1
#define EXTENSION_GL_SGIX_texture_lod_bias(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_texture_lod_bias) \
  CONST(GL_TEXTURE_LOD_BIAS_S_SGIX, 0x818E) \
  CONST(GL_TEXTURE_LOD_BIAS_T_SGIX, 0x818F) \
  CONST(GL_TEXTURE_LOD_BIAS_R_SGIX, 0x8190) \
  END()
#else
#define EXTENSION_GL_SGIX_texture_lod_bias(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_shadow_ambient
#define GL_SGIX_shadow_ambient 1
#define EXTENSION_GL_SGIX_shadow_ambient(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_shadow_ambient) \
  CONST(GL_SHADOW_AMBIENT_SGIX, 0x80BF) \
  END()
#else
#define EXTENSION_GL_SGIX_shadow_ambient(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_index_texture
#define GL_EXT_index_texture 1
#define EXTENSION_GL_EXT_index_texture(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_index_texture) \
  END()
#else
#define EXTENSION_GL_EXT_index_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_index_material
#define GL_EXT_index_material 1
#define EXTENSION_GL_EXT_index_material(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_index_material) \
  FUNC(void, glIndexMaterialEXT, GLINDEXMATERIALEXT, (GLenum face, GLenum mode)) \
  CONST(GL_INDEX_MATERIAL_EXT, 0x81B8) \
  CONST(GL_INDEX_MATERIAL_PARAMETER_EXT, 0x81B9) \
  CONST(GL_INDEX_MATERIAL_FACE_EXT, 0x81BA) \
  END()
#else
#define EXTENSION_GL_EXT_index_material(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_index_func
#define GL_EXT_index_func 1
#define EXTENSION_GL_EXT_index_func(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_index_func) \
  FUNC(void, glIndexFuncEXT, GLINDEXFUNCEXT, (GLenum func, GLclampf ref)) \
  CONST(GL_INDEX_TEST_EXT, 0x81B5) \
  CONST(GL_INDEX_TEST_FUNC_EXT, 0x81B6) \
  CONST(GL_INDEX_TEST_REF_EXT, 0x81B7) \
  END()
#else
#define EXTENSION_GL_EXT_index_func(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_index_array_formats
#define GL_EXT_index_array_formats 1
#define EXTENSION_GL_EXT_index_array_formats(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_index_array_formats) \
  CONST(GL_IUI_V2F_EXT, 0x81AD) \
  CONST(GL_IUI_V3F_EXT, 0x81AE) \
  CONST(GL_IUI_N3F_V2F_EXT, 0x81AF) \
  CONST(GL_IUI_N3F_V3F_EXT, 0x81B0) \
  CONST(GL_T2F_IUI_V2F_EXT, 0x81B1) \
  CONST(GL_T2F_IUI_V3F_EXT, 0x81B2) \
  CONST(GL_T2F_IUI_N3F_V2F_EXT, 0x81B3) \
  CONST(GL_T2F_IUI_N3F_V3F_EXT, 0x81B4) \
  END()
#else
#define EXTENSION_GL_EXT_index_array_formats(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_compiled_vertex_array
#define GL_EXT_compiled_vertex_array 1
#define EXTENSION_GL_EXT_compiled_vertex_array(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_compiled_vertex_array) \
  FUNC(void, glLockArraysEXT, GLLOCKARRAYSEXT, (GLint first, GLsizei count)) \
  FUNC(void, glUnlockArraysEXT, GLUNLOCKARRAYSEXT, ()) \
  CONST(GL_ARRAY_ELEMENT_LOCK_FIRST_EXT, 0x81A8) \
  CONST(GL_ARRAY_ELEMENT_LOCK_COUNT_EXT, 0x81A9) \
  END()
#else
#define EXTENSION_GL_EXT_compiled_vertex_array(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_cull_vertex
#define GL_EXT_cull_vertex 1
#define EXTENSION_GL_EXT_cull_vertex(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_cull_vertex) \
  FUNC(void, glCullParameterdvEXT, GLCULLPARAMETERDVEXT, (GLenum pname, GLdouble * params)) \
  FUNC(void, glCullParameterfvEXT, GLCULLPARAMETERFVEXT, (GLenum pname, GLfloat * params)) \
  CONST(GL_CULL_VERTEX_EXT, 0x81AA) \
  CONST(GL_CULL_VERTEX_EYE_POSITION_EXT, 0x81AB) \
  CONST(GL_CULL_VERTEX_OBJECT_POSITION_EXT, 0x81AC) \
  END()
#else
#define EXTENSION_GL_EXT_cull_vertex(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_ycrcb
#define GL_SGIX_ycrcb 1
#define EXTENSION_GL_SGIX_ycrcb(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_ycrcb) \
  CONST(GL_YCRCB_422_SGIX, 0x81BB) \
  CONST(GL_YCRCB_444_SGIX, 0x81BC) \
  END()
#else
#define EXTENSION_GL_SGIX_ycrcb(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_fragment_lighting
#define GL_SGIX_fragment_lighting 1
#define EXTENSION_GL_SGIX_fragment_lighting(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_fragment_lighting) \
  FUNC(void, glFragmentColorMaterialSGIX, GLFRAGMENTCOLORMATERIALSGIX, (GLenum face, GLenum mode)) \
  FUNC(void, glFragmentLightfSGIX, GLFRAGMENTLIGHTFSGIX, (GLenum light, GLenum pname, GLfloat param)) \
  FUNC(void, glFragmentLightfvSGIX, GLFRAGMENTLIGHTFVSGIX, (GLenum light, GLenum pname, const GLfloat * params)) \
  FUNC(void, glFragmentLightiSGIX, GLFRAGMENTLIGHTISGIX, (GLenum light, GLenum pname, GLint param)) \
  FUNC(void, glFragmentLightivSGIX, GLFRAGMENTLIGHTIVSGIX, (GLenum light, GLenum pname, const GLint * params)) \
  FUNC(void, glFragmentLightModelfSGIX, GLFRAGMENTLIGHTMODELFSGIX, (GLenum pname, GLfloat param)) \
  FUNC(void, glFragmentLightModelfvSGIX, GLFRAGMENTLIGHTMODELFVSGIX, (GLenum pname, const GLfloat * params)) \
  FUNC(void, glFragmentLightModeliSGIX, GLFRAGMENTLIGHTMODELISGIX, (GLenum pname, GLint param)) \
  FUNC(void, glFragmentLightModelivSGIX, GLFRAGMENTLIGHTMODELIVSGIX, (GLenum pname, const GLint * params)) \
  FUNC(void, glFragmentMaterialfSGIX, GLFRAGMENTMATERIALFSGIX, (GLenum face, GLenum pname, GLfloat param)) \
  FUNC(void, glFragmentMaterialfvSGIX, GLFRAGMENTMATERIALFVSGIX, (GLenum face, GLenum pname, const GLfloat * params)) \
  FUNC(void, glFragmentMaterialiSGIX, GLFRAGMENTMATERIALISGIX, (GLenum face, GLenum pname, GLint param)) \
  FUNC(void, glFragmentMaterialivSGIX, GLFRAGMENTMATERIALIVSGIX, (GLenum face, GLenum pname, const GLint * params)) \
  FUNC(void, glGetFragmentLightfvSGIX, GLGETFRAGMENTLIGHTFVSGIX, (GLenum light, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetFragmentLightivSGIX, GLGETFRAGMENTLIGHTIVSGIX, (GLenum light, GLenum pname, GLint * params)) \
  FUNC(void, glGetFragmentMaterialfvSGIX, GLGETFRAGMENTMATERIALFVSGIX, (GLenum face, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetFragmentMaterialivSGIX, GLGETFRAGMENTMATERIALIVSGIX, (GLenum face, GLenum pname, GLint * params)) \
  FUNC(void, glLightEnviSGIX, GLLIGHTENVISGIX, (GLenum pname, GLint param)) \
  CONST(GL_FRAGMENT_LIGHTING_SGIX, 0x8400) \
  CONST(GL_FRAGMENT_COLOR_MATERIAL_SGIX, 0x8401) \
  CONST(GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX, 0x8402) \
  CONST(GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX, 0x8403) \
  CONST(GL_MAX_FRAGMENT_LIGHTS_SGIX, 0x8404) \
  CONST(GL_MAX_ACTIVE_LIGHTS_SGIX, 0x8405) \
  CONST(GL_CURRENT_RASTER_NORMAL_SGIX, 0x8406) \
  CONST(GL_LIGHT_ENV_MODE_SGIX, 0x8407) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX, 0x8408) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX, 0x8409) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX, 0x840A) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX, 0x840B) \
  CONST(GL_FRAGMENT_LIGHT0_SGIX, 0x840C) \
  CONST(GL_FRAGMENT_LIGHT1_SGIX, 0x840D) \
  CONST(GL_FRAGMENT_LIGHT2_SGIX, 0x840E) \
  CONST(GL_FRAGMENT_LIGHT3_SGIX, 0x840F) \
  CONST(GL_FRAGMENT_LIGHT4_SGIX, 0x8410) \
  CONST(GL_FRAGMENT_LIGHT5_SGIX, 0x8411) \
  CONST(GL_FRAGMENT_LIGHT6_SGIX, 0x8412) \
  CONST(GL_FRAGMENT_LIGHT7_SGIX, 0x8413) \
  END()
#else
#define EXTENSION_GL_SGIX_fragment_lighting(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_IBM_rasterpos_clip
#define GL_IBM_rasterpos_clip 1
#define EXTENSION_GL_IBM_rasterpos_clip(NAME, FUNC, CONST, END) \
  NAME(GL_IBM_rasterpos_clip) \
  CONST(GL_RASTER_POSITION_UNCLIPPED_IBM, 0x19262) \
  END()
#else
#define EXTENSION_GL_IBM_rasterpos_clip(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_HP_texture_lighting
#define GL_HP_texture_lighting 1
#define EXTENSION_GL_HP_texture_lighting(NAME, FUNC, CONST, END) \
  NAME(GL_HP_texture_lighting) \
  CONST(GL_TEXTURE_LIGHTING_MODE_HP, 0x8167) \
  CONST(GL_TEXTURE_POST_SPECULAR_HP, 0x8168) \
  CONST(GL_TEXTURE_PRE_SPECULAR_HP, 0x8169) \
  END()
#else
#define EXTENSION_GL_HP_texture_lighting(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_draw_range_elements
#define GL_EXT_draw_range_elements 1
#define EXTENSION_GL_EXT_draw_range_elements(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_draw_range_elements) \
  FUNC(void, glDrawRangeElementsEXT, GLDRAWRANGEELEMENTSEXT, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)) \
  CONST(GL_MAX_ELEMENTS_VERTICES_EXT, 0x80E8) \
  CONST(GL_MAX_ELEMENTS_INDICES_EXT, 0x80E9) \
  END()
#else
#define EXTENSION_GL_EXT_draw_range_elements(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_WIN_phong_shading
#define GL_WIN_phong_shading 1
#define EXTENSION_GL_WIN_phong_shading(NAME, FUNC, CONST, END) \
  NAME(GL_WIN_phong_shading) \
  CONST(GL_PHONG_WIN, 0x80EA) \
  CONST(GL_PHONG_HINT_WIN, 0x80EB) \
  END()
#else
#define EXTENSION_GL_WIN_phong_shading(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_WIN_specular_fog
#define GL_WIN_specular_fog 1
#define EXTENSION_GL_WIN_specular_fog(NAME, FUNC, CONST, END) \
  NAME(GL_WIN_specular_fog) \
  CONST(GL_FOG_SPECULAR_TEXTURE_WIN, 0x80EC) \
  END()
#else
#define EXTENSION_GL_WIN_specular_fog(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_light_texture
#define GL_EXT_light_texture 1
#define EXTENSION_GL_EXT_light_texture(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_light_texture) \
  FUNC(void, glApplyTextureEXT, GLAPPLYTEXTUREEXT, (GLenum mode)) \
  FUNC(void, glTextureLightEXT, GLTEXTURELIGHTEXT, (GLenum pname)) \
  FUNC(void, glTextureMaterialEXT, GLTEXTUREMATERIALEXT, (GLenum face, GLenum mode)) \
  CONST(GL_FRAGMENT_MATERIAL_EXT, 0x8349) \
  CONST(GL_FRAGMENT_NORMAL_EXT, 0x834A) \
  CONST(GL_FRAGMENT_COLOR_EXT, 0x834C) \
  CONST(GL_ATTENUATION_EXT, 0x834D) \
  CONST(GL_SHADOW_ATTENUATION_EXT, 0x834E) \
  CONST(GL_TEXTURE_APPLICATION_MODE_EXT, 0x834F) \
  CONST(GL_TEXTURE_LIGHT_EXT, 0x8350) \
  CONST(GL_TEXTURE_MATERIAL_FACE_EXT, 0x8351) \
  CONST(GL_TEXTURE_MATERIAL_PARAMETER_EXT, 0x8352) \
  END()
#else
#define EXTENSION_GL_EXT_light_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_blend_alpha_minmax
#define GL_SGIX_blend_alpha_minmax 1
#define EXTENSION_GL_SGIX_blend_alpha_minmax(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_blend_alpha_minmax) \
  CONST(GL_ALPHA_MIN_SGIX, 0x8320) \
  CONST(GL_ALPHA_MAX_SGIX, 0x8321) \
  END()
#else
#define EXTENSION_GL_SGIX_blend_alpha_minmax(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_impact_pixel_texture
#define GL_SGIX_impact_pixel_texture 1
#define EXTENSION_GL_SGIX_impact_pixel_texture(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_impact_pixel_texture) \
  CONST(GL_PIXEL_TEX_GEN_Q_CEILING_SGIX, 0x8184) \
  CONST(GL_PIXEL_TEX_GEN_Q_ROUND_SGIX, 0x8185) \
  CONST(GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX, 0x8186) \
  CONST(GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX, 0x8187) \
  CONST(GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX, 0x8188) \
  CONST(GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX, 0x8189) \
  CONST(GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX, 0x818A) \
  END()
#else
#define EXTENSION_GL_SGIX_impact_pixel_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_bgra
#define GL_EXT_bgra 1
#define EXTENSION_GL_EXT_bgra(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_bgra) \
  CONST(GL_BGR_EXT, 0x80E0) \
  CONST(GL_BGRA_EXT, 0x80E1) \
  END()
#else
#define EXTENSION_GL_EXT_bgra(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_async
#define GL_SGIX_async 1
#define EXTENSION_GL_SGIX_async(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_async) \
  FUNC(void, glAsyncMarkerSGIX, GLASYNCMARKERSGIX, (GLuint marker)) \
  FUNC(GLint, glFinishAsyncSGIX, GLFINISHASYNCSGIX, (GLuint * markerp)) \
  FUNC(GLint, glPollAsyncSGIX, GLPOLLASYNCSGIX, (GLuint * markerp)) \
  FUNC(GLuint, glGenAsyncMarkersSGIX, GLGENASYNCMARKERSSGIX, (GLsizei range)) \
  FUNC(void, glDeleteAsyncMarkersSGIX, GLDELETEASYNCMARKERSSGIX, (GLuint marker, GLsizei range)) \
  FUNC(GLboolean, glIsAsyncMarkerSGIX, GLISASYNCMARKERSGIX, (GLuint marker)) \
  CONST(GL_ASYNC_MARKER_SGIX, 0x8329) \
  END()
#else
#define EXTENSION_GL_SGIX_async(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_async_pixel
#define GL_SGIX_async_pixel 1
#define EXTENSION_GL_SGIX_async_pixel(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_async_pixel) \
  CONST(GL_ASYNC_TEX_IMAGE_SGIX, 0x835C) \
  CONST(GL_ASYNC_DRAW_PIXELS_SGIX, 0x835D) \
  CONST(GL_ASYNC_READ_PIXELS_SGIX, 0x835E) \
  CONST(GL_MAX_ASYNC_TEX_IMAGE_SGIX, 0x835F) \
  CONST(GL_MAX_ASYNC_DRAW_PIXELS_SGIX, 0x8360) \
  CONST(GL_MAX_ASYNC_READ_PIXELS_SGIX, 0x8361) \
  END()
#else
#define EXTENSION_GL_SGIX_async_pixel(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_async_histogram
#define GL_SGIX_async_histogram 1
#define EXTENSION_GL_SGIX_async_histogram(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_async_histogram) \
  CONST(GL_ASYNC_HISTOGRAM_SGIX, 0x832C) \
  CONST(GL_MAX_ASYNC_HISTOGRAM_SGIX, 0x832D) \
  END()
#else
#define EXTENSION_GL_SGIX_async_histogram(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_INTEL_texture_scissor
#define GL_INTEL_texture_scissor 1
#define EXTENSION_GL_INTEL_texture_scissor(NAME, FUNC, CONST, END) \
  NAME(GL_INTEL_texture_scissor) \
  END()
#else
#define EXTENSION_GL_INTEL_texture_scissor(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_INTEL_parallel_arrays
#define GL_INTEL_parallel_arrays 1
#define EXTENSION_GL_INTEL_parallel_arrays(NAME, FUNC, CONST, END) \
  NAME(GL_INTEL_parallel_arrays) \
  FUNC(void, glVertexPointervINTEL, GLVERTEXPOINTERVINTEL, (GLint size, GLenum type, const GLvoid* * pointer)) \
  FUNC(void, glNormalPointervINTEL, GLNORMALPOINTERVINTEL, (GLenum type, const GLvoid* * pointer)) \
  FUNC(void, glColorPointervINTEL, GLCOLORPOINTERVINTEL, (GLint size, GLenum type, const GLvoid* * pointer)) \
  FUNC(void, glTexCoordPointervINTEL, GLTEXCOORDPOINTERVINTEL, (GLint size, GLenum type, const GLvoid* * pointer)) \
  CONST(GL_PARALLEL_ARRAYS_INTEL, 0x83F4) \
  CONST(GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL, 0x83F5) \
  CONST(GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL, 0x83F6) \
  CONST(GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL, 0x83F7) \
  CONST(GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL, 0x83F8) \
  END()
#else
#define EXTENSION_GL_INTEL_parallel_arrays(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_HP_occlusion_test
#define GL_HP_occlusion_test 1
#define EXTENSION_GL_HP_occlusion_test(NAME, FUNC, CONST, END) \
  NAME(GL_HP_occlusion_test) \
  CONST(GL_OCCLUSION_TEST_HP, 0x8165) \
  CONST(GL_OCCLUSION_TEST_RESULT_HP, 0x8166) \
  END()
#else
#define EXTENSION_GL_HP_occlusion_test(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_pixel_transform
#define GL_EXT_pixel_transform 1
#define EXTENSION_GL_EXT_pixel_transform(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_pixel_transform) \
  FUNC(void, glPixelTransformParameteriEXT, GLPIXELTRANSFORMPARAMETERIEXT, (GLenum target, GLenum pname, GLint param)) \
  FUNC(void, glPixelTransformParameterfEXT, GLPIXELTRANSFORMPARAMETERFEXT, (GLenum target, GLenum pname, GLfloat param)) \
  FUNC(void, glPixelTransformParameterivEXT, GLPIXELTRANSFORMPARAMETERIVEXT, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glPixelTransformParameterfvEXT, GLPIXELTRANSFORMPARAMETERFVEXT, (GLenum target, GLenum pname, const GLfloat * params)) \
  CONST(GL_PIXEL_TRANSFORM_2D_EXT, 0x8330) \
  CONST(GL_PIXEL_MAG_FILTER_EXT, 0x8331) \
  CONST(GL_PIXEL_MIN_FILTER_EXT, 0x8332) \
  CONST(GL_PIXEL_CUBIC_WEIGHT_EXT, 0x8333) \
  CONST(GL_CUBIC_EXT, 0x8334) \
  CONST(GL_AVERAGE_EXT, 0x8335) \
  CONST(GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT, 0x8336) \
  CONST(GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT, 0x8337) \
  CONST(GL_PIXEL_TRANSFORM_2D_MATRIX_EXT, 0x8338) \
  END()
#else
#define EXTENSION_GL_EXT_pixel_transform(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_pixel_transform_color_table
#define GL_EXT_pixel_transform_color_table 1
#define EXTENSION_GL_EXT_pixel_transform_color_table(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_pixel_transform_color_table) \
  END()
#else
#define EXTENSION_GL_EXT_pixel_transform_color_table(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_shared_texture_palette
#define GL_EXT_shared_texture_palette 1
#define EXTENSION_GL_EXT_shared_texture_palette(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_shared_texture_palette) \
  CONST(GL_SHARED_TEXTURE_PALETTE_EXT, 0x81FB) \
  END()
#else
#define EXTENSION_GL_EXT_shared_texture_palette(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_separate_specular_color
#define GL_EXT_separate_specular_color 1
#define EXTENSION_GL_EXT_separate_specular_color(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_separate_specular_color) \
  CONST(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, 0x81F8) \
  CONST(GL_SINGLE_COLOR_EXT, 0x81F9) \
  CONST(GL_SEPARATE_SPECULAR_COLOR_EXT, 0x81FA) \
  END()
#else
#define EXTENSION_GL_EXT_separate_specular_color(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_secondary_color
#define GL_EXT_secondary_color 1
#define EXTENSION_GL_EXT_secondary_color(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_secondary_color) \
  FUNC(void, glSecondaryColor3bEXT, GLSECONDARYCOLOR3BEXT, (GLbyte red, GLbyte green, GLbyte blue)) \
  FUNC(void, glSecondaryColor3bvEXT, GLSECONDARYCOLOR3BVEXT, (const GLbyte * v)) \
  FUNC(void, glSecondaryColor3dEXT, GLSECONDARYCOLOR3DEXT, (GLdouble red, GLdouble green, GLdouble blue)) \
  FUNC(void, glSecondaryColor3dvEXT, GLSECONDARYCOLOR3DVEXT, (const GLdouble * v)) \
  FUNC(void, glSecondaryColor3fEXT, GLSECONDARYCOLOR3FEXT, (GLfloat red, GLfloat green, GLfloat blue)) \
  FUNC(void, glSecondaryColor3fvEXT, GLSECONDARYCOLOR3FVEXT, (const GLfloat * v)) \
  FUNC(void, glSecondaryColor3iEXT, GLSECONDARYCOLOR3IEXT, (GLint red, GLint green, GLint blue)) \
  FUNC(void, glSecondaryColor3ivEXT, GLSECONDARYCOLOR3IVEXT, (const GLint * v)) \
  FUNC(void, glSecondaryColor3sEXT, GLSECONDARYCOLOR3SEXT, (GLshort red, GLshort green, GLshort blue)) \
  FUNC(void, glSecondaryColor3svEXT, GLSECONDARYCOLOR3SVEXT, (const GLshort * v)) \
  FUNC(void, glSecondaryColor3ubEXT, GLSECONDARYCOLOR3UBEXT, (GLubyte red, GLubyte green, GLubyte blue)) \
  FUNC(void, glSecondaryColor3ubvEXT, GLSECONDARYCOLOR3UBVEXT, (const GLubyte * v)) \
  FUNC(void, glSecondaryColor3uiEXT, GLSECONDARYCOLOR3UIEXT, (GLuint red, GLuint green, GLuint blue)) \
  FUNC(void, glSecondaryColor3uivEXT, GLSECONDARYCOLOR3UIVEXT, (const GLuint * v)) \
  FUNC(void, glSecondaryColor3usEXT, GLSECONDARYCOLOR3USEXT, (GLushort red, GLushort green, GLushort blue)) \
  FUNC(void, glSecondaryColor3usvEXT, GLSECONDARYCOLOR3USVEXT, (const GLushort * v)) \
  FUNC(void, glSecondaryColorPointerEXT, GLSECONDARYCOLORPOINTEREXT, (GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)) \
  CONST(GL_COLOR_SUM_EXT, 0x8458) \
  CONST(GL_CURRENT_SECONDARY_COLOR_EXT, 0x8459) \
  CONST(GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, 0x845A) \
  CONST(GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, 0x845B) \
  CONST(GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, 0x845C) \
  CONST(GL_SECONDARY_COLOR_ARRAY_POINTER_EXT, 0x845D) \
  CONST(GL_SECONDARY_COLOR_ARRAY_EXT, 0x845E) \
  END()
#else
#define EXTENSION_GL_EXT_secondary_color(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_perturb_normal
#define GL_EXT_texture_perturb_normal 1
#define EXTENSION_GL_EXT_texture_perturb_normal(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_perturb_normal) \
  FUNC(void, glTextureNormalEXT, GLTEXTURENORMALEXT, (GLenum mode)) \
  CONST(GL_PERTURB_EXT, 0x85AE) \
  CONST(GL_TEXTURE_NORMAL_EXT, 0x85AF) \
  END()
#else
#define EXTENSION_GL_EXT_texture_perturb_normal(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_multi_draw_arrays
#define GL_EXT_multi_draw_arrays 1
#define EXTENSION_GL_EXT_multi_draw_arrays(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_multi_draw_arrays) \
  FUNC(void, glMultiDrawArraysEXT, GLMULTIDRAWARRAYSEXT, (GLenum mode, GLint * first, GLsizei * count, GLsizei primcount)) \
  FUNC(void, glMultiDrawElementsEXT, GLMULTIDRAWELEMENTSEXT, (GLenum mode, const GLsizei * count, GLenum type, const GLvoid* * indices, GLsizei primcount)) \
  END()
#else
#define EXTENSION_GL_EXT_multi_draw_arrays(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_fog_coord
#define GL_EXT_fog_coord 1
#define EXTENSION_GL_EXT_fog_coord(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_fog_coord) \
  FUNC(void, glFogCoordfEXT, GLFOGCOORDFEXT, (GLfloat coord)) \
  FUNC(void, glFogCoordfvEXT, GLFOGCOORDFVEXT, (const GLfloat * coord)) \
  FUNC(void, glFogCoorddEXT, GLFOGCOORDDEXT, (GLdouble coord)) \
  FUNC(void, glFogCoorddvEXT, GLFOGCOORDDVEXT, (const GLdouble * coord)) \
  FUNC(void, glFogCoordPointerEXT, GLFOGCOORDPOINTEREXT, (GLenum type, GLsizei stride, const GLvoid * pointer)) \
  CONST(GL_FOG_COORDINATE_SOURCE_EXT, 0x8450) \
  CONST(GL_FOG_COORDINATE_EXT, 0x8451) \
  CONST(GL_FRAGMENT_DEPTH_EXT, 0x8452) \
  CONST(GL_CURRENT_FOG_COORDINATE_EXT, 0x8453) \
  CONST(GL_FOG_COORDINATE_ARRAY_TYPE_EXT, 0x8454) \
  CONST(GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, 0x8455) \
  CONST(GL_FOG_COORDINATE_ARRAY_POINTER_EXT, 0x8456) \
  CONST(GL_FOG_COORDINATE_ARRAY_EXT, 0x8457) \
  END()
#else
#define EXTENSION_GL_EXT_fog_coord(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_REND_screen_coordinates
#define GL_REND_screen_coordinates 1
#define EXTENSION_GL_REND_screen_coordinates(NAME, FUNC, CONST, END) \
  NAME(GL_REND_screen_coordinates) \
  CONST(GL_SCREEN_COORDINATES_REND, 0x8490) \
  CONST(GL_INVERTED_SCREEN_W_REND, 0x8491) \
  END()
#else
#define EXTENSION_GL_REND_screen_coordinates(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_coordinate_frame
#define GL_EXT_coordinate_frame 1
#define EXTENSION_GL_EXT_coordinate_frame(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_coordinate_frame) \
  FUNC(void, glTangent3bEXT, GLTANGENT3BEXT, (GLbyte tx, GLbyte ty, GLbyte tz)) \
  FUNC(void, glTangent3bvEXT, GLTANGENT3BVEXT, (const GLbyte * v)) \
  FUNC(void, glTangent3dEXT, GLTANGENT3DEXT, (GLdouble tx, GLdouble ty, GLdouble tz)) \
  FUNC(void, glTangent3dvEXT, GLTANGENT3DVEXT, (const GLdouble * v)) \
  FUNC(void, glTangent3fEXT, GLTANGENT3FEXT, (GLfloat tx, GLfloat ty, GLfloat tz)) \
  FUNC(void, glTangent3fvEXT, GLTANGENT3FVEXT, (const GLfloat * v)) \
  FUNC(void, glTangent3iEXT, GLTANGENT3IEXT, (GLint tx, GLint ty, GLint tz)) \
  FUNC(void, glTangent3ivEXT, GLTANGENT3IVEXT, (const GLint * v)) \
  FUNC(void, glTangent3sEXT, GLTANGENT3SEXT, (GLshort tx, GLshort ty, GLshort tz)) \
  FUNC(void, glTangent3svEXT, GLTANGENT3SVEXT, (const GLshort * v)) \
  FUNC(void, glBinormal3bEXT, GLBINORMAL3BEXT, (GLbyte bx, GLbyte by, GLbyte bz)) \
  FUNC(void, glBinormal3bvEXT, GLBINORMAL3BVEXT, (const GLbyte * v)) \
  FUNC(void, glBinormal3dEXT, GLBINORMAL3DEXT, (GLdouble bx, GLdouble by, GLdouble bz)) \
  FUNC(void, glBinormal3dvEXT, GLBINORMAL3DVEXT, (const GLdouble * v)) \
  FUNC(void, glBinormal3fEXT, GLBINORMAL3FEXT, (GLfloat bx, GLfloat by, GLfloat bz)) \
  FUNC(void, glBinormal3fvEXT, GLBINORMAL3FVEXT, (const GLfloat * v)) \
  FUNC(void, glBinormal3iEXT, GLBINORMAL3IEXT, (GLint bx, GLint by, GLint bz)) \
  FUNC(void, glBinormal3ivEXT, GLBINORMAL3IVEXT, (const GLint * v)) \
  FUNC(void, glBinormal3sEXT, GLBINORMAL3SEXT, (GLshort bx, GLshort by, GLshort bz)) \
  FUNC(void, glBinormal3svEXT, GLBINORMAL3SVEXT, (const GLshort * v)) \
  FUNC(void, glTangentPointerEXT, GLTANGENTPOINTEREXT, (GLenum type, GLsizei stride, const GLvoid * pointer)) \
  FUNC(void, glBinormalPointerEXT, GLBINORMALPOINTEREXT, (GLenum type, GLsizei stride, const GLvoid * pointer)) \
  CONST(GL_TANGENT_ARRAY_EXT, 0x8439) \
  CONST(GL_BINORMAL_ARRAY_EXT, 0x843A) \
  CONST(GL_CURRENT_TANGENT_EXT, 0x843B) \
  CONST(GL_CURRENT_BINORMAL_EXT, 0x843C) \
  CONST(GL_TANGENT_ARRAY_TYPE_EXT, 0x843E) \
  CONST(GL_TANGENT_ARRAY_STRIDE_EXT, 0x843F) \
  CONST(GL_BINORMAL_ARRAY_TYPE_EXT, 0x8440) \
  CONST(GL_BINORMAL_ARRAY_STRIDE_EXT, 0x8441) \
  CONST(GL_TANGENT_ARRAY_POINTER_EXT, 0x8442) \
  CONST(GL_BINORMAL_ARRAY_POINTER_EXT, 0x8443) \
  CONST(GL_MAP1_TANGENT_EXT, 0x8444) \
  CONST(GL_MAP2_TANGENT_EXT, 0x8445) \
  CONST(GL_MAP1_BINORMAL_EXT, 0x8446) \
  CONST(GL_MAP2_BINORMAL_EXT, 0x8447) \
  END()
#else
#define EXTENSION_GL_EXT_coordinate_frame(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_env_combine
#define GL_EXT_texture_env_combine 1
#define EXTENSION_GL_EXT_texture_env_combine(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_env_combine) \
  CONST(GL_COMBINE_EXT, 0x8570) \
  CONST(GL_COMBINE_RGB_EXT, 0x8571) \
  CONST(GL_COMBINE_ALPHA_EXT, 0x8572) \
  CONST(GL_RGB_SCALE_EXT, 0x8573) \
  CONST(GL_ADD_SIGNED_EXT, 0x8574) \
  CONST(GL_INTERPOLATE_EXT, 0x8575) \
  CONST(GL_CONSTANT_EXT, 0x8576) \
  CONST(GL_PRIMARY_COLOR_EXT, 0x8577) \
  CONST(GL_PREVIOUS_EXT, 0x8578) \
  CONST(GL_SOURCE0_RGB_EXT, 0x8580) \
  CONST(GL_SOURCE1_RGB_EXT, 0x8581) \
  CONST(GL_SOURCE2_RGB_EXT, 0x8582) \
  CONST(GL_SOURCE0_ALPHA_EXT, 0x8588) \
  CONST(GL_SOURCE1_ALPHA_EXT, 0x8589) \
  CONST(GL_SOURCE2_ALPHA_EXT, 0x858A) \
  CONST(GL_OPERAND0_RGB_EXT, 0x8590) \
  CONST(GL_OPERAND1_RGB_EXT, 0x8591) \
  CONST(GL_OPERAND2_RGB_EXT, 0x8592) \
  CONST(GL_OPERAND0_ALPHA_EXT, 0x8598) \
  CONST(GL_OPERAND1_ALPHA_EXT, 0x8599) \
  CONST(GL_OPERAND2_ALPHA_EXT, 0x859A) \
  END()
#else
#define EXTENSION_GL_EXT_texture_env_combine(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_specular_vector
#define GL_APPLE_specular_vector 1
#define EXTENSION_GL_APPLE_specular_vector(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_specular_vector) \
  CONST(GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE, 0x85B0) \
  END()
#else
#define EXTENSION_GL_APPLE_specular_vector(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_transform_hint
#define GL_APPLE_transform_hint 1
#define EXTENSION_GL_APPLE_transform_hint(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_transform_hint) \
  CONST(GL_TRANSFORM_HINT_APPLE, 0x85B1) \
  END()
#else
#define EXTENSION_GL_APPLE_transform_hint(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_fog_scale
#define GL_SGIX_fog_scale 1
#define EXTENSION_GL_SGIX_fog_scale(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_fog_scale) \
  CONST(GL_FOG_SCALE_SGIX, 0x81FC) \
  CONST(GL_FOG_SCALE_VALUE_SGIX, 0x81FD) \
  END()
#else
#define EXTENSION_GL_SGIX_fog_scale(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SUNX_constant_data
#define GL_SUNX_constant_data 1
#define EXTENSION_GL_SUNX_constant_data(NAME, FUNC, CONST, END) \
  NAME(GL_SUNX_constant_data) \
  FUNC(void, glFinishTextureSUNX, GLFINISHTEXTURESUNX, ()) \
  CONST(GL_UNPACK_CONSTANT_DATA_SUNX, 0x81D5) \
  CONST(GL_TEXTURE_CONSTANT_DATA_SUNX, 0x81D6) \
  END()
#else
#define EXTENSION_GL_SUNX_constant_data(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SUN_global_alpha
#define GL_SUN_global_alpha 1
#define EXTENSION_GL_SUN_global_alpha(NAME, FUNC, CONST, END) \
  NAME(GL_SUN_global_alpha) \
  FUNC(void, glGlobalAlphaFactorbSUN, GLGLOBALALPHAFACTORBSUN, (GLbyte factor)) \
  FUNC(void, glGlobalAlphaFactorsSUN, GLGLOBALALPHAFACTORSSUN, (GLshort factor)) \
  FUNC(void, glGlobalAlphaFactoriSUN, GLGLOBALALPHAFACTORISUN, (GLint factor)) \
  FUNC(void, glGlobalAlphaFactorfSUN, GLGLOBALALPHAFACTORFSUN, (GLfloat factor)) \
  FUNC(void, glGlobalAlphaFactordSUN, GLGLOBALALPHAFACTORDSUN, (GLdouble factor)) \
  FUNC(void, glGlobalAlphaFactorubSUN, GLGLOBALALPHAFACTORUBSUN, (GLubyte factor)) \
  FUNC(void, glGlobalAlphaFactorusSUN, GLGLOBALALPHAFACTORUSSUN, (GLushort factor)) \
  FUNC(void, glGlobalAlphaFactoruiSUN, GLGLOBALALPHAFACTORUISUN, (GLuint factor)) \
  CONST(GL_GLOBAL_ALPHA_SUN, 0x81D9) \
  CONST(GL_GLOBAL_ALPHA_FACTOR_SUN, 0x81DA) \
  END()
#else
#define EXTENSION_GL_SUN_global_alpha(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SUN_triangle_list
#define GL_SUN_triangle_list 1
#define EXTENSION_GL_SUN_triangle_list(NAME, FUNC, CONST, END) \
  NAME(GL_SUN_triangle_list) \
  FUNC(void, glReplacementCodeuiSUN, GLREPLACEMENTCODEUISUN, (GLuint code)) \
  FUNC(void, glReplacementCodeusSUN, GLREPLACEMENTCODEUSSUN, (GLushort code)) \
  FUNC(void, glReplacementCodeubSUN, GLREPLACEMENTCODEUBSUN, (GLubyte code)) \
  FUNC(void, glReplacementCodeuivSUN, GLREPLACEMENTCODEUIVSUN, (const GLuint * code)) \
  FUNC(void, glReplacementCodeusvSUN, GLREPLACEMENTCODEUSVSUN, (const GLushort * code)) \
  FUNC(void, glReplacementCodeubvSUN, GLREPLACEMENTCODEUBVSUN, (const GLubyte * code)) \
  FUNC(void, glReplacementCodePointerSUN, GLREPLACEMENTCODEPOINTERSUN, (GLenum type, GLsizei stride, const GLvoid* * pointer)) \
  CONST(GL_RESTART_SUN, 0x0001) \
  CONST(GL_REPLACE_MIDDLE_SUN, 0x0002) \
  CONST(GL_REPLACE_OLDEST_SUN, 0x0003) \
  CONST(GL_TRIANGLE_LIST_SUN, 0x81D7) \
  CONST(GL_REPLACEMENT_CODE_SUN, 0x81D8) \
  CONST(GL_REPLACEMENT_CODE_ARRAY_SUN, 0x85C0) \
  CONST(GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN, 0x85C1) \
  CONST(GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN, 0x85C2) \
  CONST(GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN, 0x85C3) \
  CONST(GL_R1UI_V3F_SUN, 0x85C4) \
  CONST(GL_R1UI_C4UB_V3F_SUN, 0x85C5) \
  CONST(GL_R1UI_C3F_V3F_SUN, 0x85C6) \
  CONST(GL_R1UI_N3F_V3F_SUN, 0x85C7) \
  CONST(GL_R1UI_C4F_N3F_V3F_SUN, 0x85C8) \
  CONST(GL_R1UI_T2F_V3F_SUN, 0x85C9) \
  CONST(GL_R1UI_T2F_N3F_V3F_SUN, 0x85CA) \
  CONST(GL_R1UI_T2F_C4F_N3F_V3F_SUN, 0x85CB) \
  END()
#else
#define EXTENSION_GL_SUN_triangle_list(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SUN_vertex
#define GL_SUN_vertex 1
#define EXTENSION_GL_SUN_vertex(NAME, FUNC, CONST, END) \
  NAME(GL_SUN_vertex) \
  FUNC(void, glColor4ubVertex2fSUN, GLCOLOR4UBVERTEX2FSUN, (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)) \
  FUNC(void, glColor4ubVertex2fvSUN, GLCOLOR4UBVERTEX2FVSUN, (const GLubyte * c, const GLfloat * v)) \
  FUNC(void, glColor4ubVertex3fSUN, GLCOLOR4UBVERTEX3FSUN, (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glColor4ubVertex3fvSUN, GLCOLOR4UBVERTEX3FVSUN, (const GLubyte * c, const GLfloat * v)) \
  FUNC(void, glColor3fVertex3fSUN, GLCOLOR3FVERTEX3FSUN, (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glColor3fVertex3fvSUN, GLCOLOR3FVERTEX3FVSUN, (const GLfloat * c, const GLfloat * v)) \
  FUNC(void, glNormal3fVertex3fSUN, GLNORMAL3FVERTEX3FSUN, (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glNormal3fVertex3fvSUN, GLNORMAL3FVERTEX3FVSUN, (const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glColor4fNormal3fVertex3fSUN, GLCOLOR4FNORMAL3FVERTEX3FSUN, (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glColor4fNormal3fVertex3fvSUN, GLCOLOR4FNORMAL3FVERTEX3FVSUN, (const GLfloat * c, const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glTexCoord2fVertex3fSUN, GLTEXCOORD2FVERTEX3FSUN, (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glTexCoord2fVertex3fvSUN, GLTEXCOORD2FVERTEX3FVSUN, (const GLfloat * tc, const GLfloat * v)) \
  FUNC(void, glTexCoord4fVertex4fSUN, GLTEXCOORD4FVERTEX4FSUN, (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glTexCoord4fVertex4fvSUN, GLTEXCOORD4FVERTEX4FVSUN, (const GLfloat * tc, const GLfloat * v)) \
  FUNC(void, glTexCoord2fColor4ubVertex3fSUN, GLTEXCOORD2FCOLOR4UBVERTEX3FSUN, (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glTexCoord2fColor4ubVertex3fvSUN, GLTEXCOORD2FCOLOR4UBVERTEX3FVSUN, (const GLfloat * tc, const GLubyte * c, const GLfloat * v)) \
  FUNC(void, glTexCoord2fColor3fVertex3fSUN, GLTEXCOORD2FCOLOR3FVERTEX3FSUN, (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glTexCoord2fColor3fVertex3fvSUN, GLTEXCOORD2FCOLOR3FVERTEX3FVSUN, (const GLfloat * tc, const GLfloat * c, const GLfloat * v)) \
  FUNC(void, glTexCoord2fNormal3fVertex3fSUN, GLTEXCOORD2FNORMAL3FVERTEX3FSUN, (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glTexCoord2fNormal3fVertex3fvSUN, GLTEXCOORD2FNORMAL3FVERTEX3FVSUN, (const GLfloat * tc, const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glTexCoord2fColor4fNormal3fVertex3fSUN, GLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUN, (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glTexCoord2fColor4fNormal3fVertex3fvSUN, GLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUN, (const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glTexCoord4fColor4fNormal3fVertex4fSUN, GLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUN, (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glTexCoord4fColor4fNormal3fVertex4fvSUN, GLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUN, (const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiVertex3fSUN, GLREPLACEMENTCODEUIVERTEX3FSUN, (GLuint rc, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiVertex3fvSUN, GLREPLACEMENTCODEUIVERTEX3FVSUN, (const GLuint * rc, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiColor4ubVertex3fSUN, GLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUN, (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiColor4ubVertex3fvSUN, GLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUN, (const GLuint * rc, const GLubyte * c, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiColor3fVertex3fSUN, GLREPLACEMENTCODEUICOLOR3FVERTEX3FSUN, (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiColor3fVertex3fvSUN, GLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUN, (const GLuint * rc, const GLfloat * c, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiNormal3fVertex3fSUN, GLREPLACEMENTCODEUINORMAL3FVERTEX3FSUN, (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiNormal3fVertex3fvSUN, GLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUN, (const GLuint * rc, const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiColor4fNormal3fVertex3fSUN, GLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUN, (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiColor4fNormal3fVertex3fvSUN, GLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUN, (const GLuint * rc, const GLfloat * c, const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiTexCoord2fVertex3fSUN, GLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUN, (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiTexCoord2fVertex3fvSUN, GLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUN, (const GLuint * rc, const GLfloat * tc, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, GLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUN, (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, GLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUN, (const GLuint * rc, const GLfloat * tc, const GLfloat * n, const GLfloat * v)) \
  FUNC(void, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, GLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUN, (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, GLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUN, (const GLuint * rc, const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)) \
  END()
#else
#define EXTENSION_GL_SUN_vertex(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_blend_func_separate
#define GL_EXT_blend_func_separate 1
#define EXTENSION_GL_EXT_blend_func_separate(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_blend_func_separate) \
  FUNC(void, glBlendFuncSeparateEXT, GLBLENDFUNCSEPARATEEXT, (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)) \
  CONST(GL_BLEND_DST_RGB_EXT, 0x80C8) \
  CONST(GL_BLEND_SRC_RGB_EXT, 0x80C9) \
  CONST(GL_BLEND_DST_ALPHA_EXT, 0x80CA) \
  CONST(GL_BLEND_SRC_ALPHA_EXT, 0x80CB) \
  END()
#else
#define EXTENSION_GL_EXT_blend_func_separate(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_INGR_color_clamp
#define GL_INGR_color_clamp 1
#define EXTENSION_GL_INGR_color_clamp(NAME, FUNC, CONST, END) \
  NAME(GL_INGR_color_clamp) \
  CONST(GL_RED_MIN_CLAMP_INGR, 0x8560) \
  CONST(GL_GREEN_MIN_CLAMP_INGR, 0x8561) \
  CONST(GL_BLUE_MIN_CLAMP_INGR, 0x8562) \
  CONST(GL_ALPHA_MIN_CLAMP_INGR, 0x8563) \
  CONST(GL_RED_MAX_CLAMP_INGR, 0x8564) \
  CONST(GL_GREEN_MAX_CLAMP_INGR, 0x8565) \
  CONST(GL_BLUE_MAX_CLAMP_INGR, 0x8566) \
  CONST(GL_ALPHA_MAX_CLAMP_INGR, 0x8567) \
  END()
#else
#define EXTENSION_GL_INGR_color_clamp(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_INGR_interlace_read
#define GL_INGR_interlace_read 1
#define EXTENSION_GL_INGR_interlace_read(NAME, FUNC, CONST, END) \
  NAME(GL_INGR_interlace_read) \
  CONST(GL_INTERLACE_READ_INGR, 0x8568) \
  END()
#else
#define EXTENSION_GL_INGR_interlace_read(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_stencil_wrap
#define GL_EXT_stencil_wrap 1
#define EXTENSION_GL_EXT_stencil_wrap(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_stencil_wrap) \
  CONST(GL_INCR_WRAP_EXT, 0x8507) \
  CONST(GL_DECR_WRAP_EXT, 0x8508) \
  END()
#else
#define EXTENSION_GL_EXT_stencil_wrap(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_422_pixels
#define GL_EXT_422_pixels 1
#define EXTENSION_GL_EXT_422_pixels(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_422_pixels) \
  CONST(GL_422_EXT, 0x80CC) \
  CONST(GL_422_REV_EXT, 0x80CD) \
  CONST(GL_422_AVERAGE_EXT, 0x80CE) \
  CONST(GL_422_REV_AVERAGE_EXT, 0x80CF) \
  END()
#else
#define EXTENSION_GL_EXT_422_pixels(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texgen_reflection
#define GL_NV_texgen_reflection 1
#define EXTENSION_GL_NV_texgen_reflection(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texgen_reflection) \
  CONST(GL_NORMAL_MAP_NV, 0x8511) \
  CONST(GL_REFLECTION_MAP_NV, 0x8512) \
  END()
#else
#define EXTENSION_GL_NV_texgen_reflection(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_cube_map
#define GL_EXT_texture_cube_map 1
#define EXTENSION_GL_EXT_texture_cube_map(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_cube_map) \
  CONST(GL_NORMAL_MAP_EXT, 0x8511) \
  CONST(GL_REFLECTION_MAP_EXT, 0x8512) \
  CONST(GL_TEXTURE_CUBE_MAP_EXT, 0x8513) \
  CONST(GL_TEXTURE_BINDING_CUBE_MAP_EXT, 0x8514) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT, 0x8515) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT, 0x8516) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT, 0x8517) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT, 0x8518) \
  CONST(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT, 0x8519) \
  CONST(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT, 0x851A) \
  CONST(GL_PROXY_TEXTURE_CUBE_MAP_EXT, 0x851B) \
  CONST(GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT, 0x851C) \
  END()
#else
#define EXTENSION_GL_EXT_texture_cube_map(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SUN_convolution_border_modes
#define GL_SUN_convolution_border_modes 1
#define EXTENSION_GL_SUN_convolution_border_modes(NAME, FUNC, CONST, END) \
  NAME(GL_SUN_convolution_border_modes) \
  CONST(GL_WRAP_BORDER_SUN, 0x81D4) \
  END()
#else
#define EXTENSION_GL_SUN_convolution_border_modes(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_env_add
#define GL_EXT_texture_env_add 1
#define EXTENSION_GL_EXT_texture_env_add(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_env_add) \
  END()
#else
#define EXTENSION_GL_EXT_texture_env_add(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_lod_bias
#define GL_EXT_texture_lod_bias 1
#define EXTENSION_GL_EXT_texture_lod_bias(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_lod_bias) \
  CONST(GL_MAX_TEXTURE_LOD_BIAS_EXT, 0x84FD) \
  CONST(GL_TEXTURE_FILTER_CONTROL_EXT, 0x8500) \
  CONST(GL_TEXTURE_LOD_BIAS_EXT, 0x8501) \
  END()
#else
#define EXTENSION_GL_EXT_texture_lod_bias(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_filter_anisotropic
#define GL_EXT_texture_filter_anisotropic 1
#define EXTENSION_GL_EXT_texture_filter_anisotropic(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_filter_anisotropic) \
  CONST(GL_TEXTURE_MAX_ANISOTROPY_EXT, 0x84FE) \
  CONST(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, 0x84FF) \
  END()
#else
#define EXTENSION_GL_EXT_texture_filter_anisotropic(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_vertex_weighting
#define GL_EXT_vertex_weighting 1
#define EXTENSION_GL_EXT_vertex_weighting(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_vertex_weighting) \
  FUNC(void, glVertexWeightfEXT, GLVERTEXWEIGHTFEXT, (GLfloat weight)) \
  FUNC(void, glVertexWeightfvEXT, GLVERTEXWEIGHTFVEXT, (const GLfloat * weight)) \
  FUNC(void, glVertexWeightPointerEXT, GLVERTEXWEIGHTPOINTEREXT, (GLsizei size, GLenum type, GLsizei stride, const GLvoid * pointer)) \
  CONST(GL_MODELVIEW0_STACK_DEPTH_EXT, GL_MODELVIEW_STACK_DEPTH) \
  CONST(GL_MODELVIEW1_STACK_DEPTH_EXT, 0x8502) \
  CONST(GL_MODELVIEW0_MATRIX_EXT, GL_MODELVIEW_MATRIX) \
  CONST(GL_MODELVIEW1_MATRIX_EXT, 0x8506) \
  CONST(GL_VERTEX_WEIGHTING_EXT, 0x8509) \
  CONST(GL_MODELVIEW0_EXT, GL_MODELVIEW) \
  CONST(GL_MODELVIEW1_EXT, 0x850A) \
  CONST(GL_CURRENT_VERTEX_WEIGHT_EXT, 0x850B) \
  CONST(GL_VERTEX_WEIGHT_ARRAY_EXT, 0x850C) \
  CONST(GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT, 0x850D) \
  CONST(GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT, 0x850E) \
  CONST(GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT, 0x850F) \
  CONST(GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT, 0x8510) \
  END()
#else
#define EXTENSION_GL_EXT_vertex_weighting(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_light_max_exponent
#define GL_NV_light_max_exponent 1
#define EXTENSION_GL_NV_light_max_exponent(NAME, FUNC, CONST, END) \
  NAME(GL_NV_light_max_exponent) \
  CONST(GL_MAX_SHININESS_NV, 0x8504) \
  CONST(GL_MAX_SPOT_EXPONENT_NV, 0x8505) \
  END()
#else
#define EXTENSION_GL_NV_light_max_exponent(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_vertex_array_range
#define GL_NV_vertex_array_range 1
#define EXTENSION_GL_NV_vertex_array_range(NAME, FUNC, CONST, END) \
  NAME(GL_NV_vertex_array_range) \
  FUNC(void, glFlushVertexArrayRangeNV, GLFLUSHVERTEXARRAYRANGENV, ()) \
  FUNC(void, glVertexArrayRangeNV, GLVERTEXARRAYRANGENV, (GLsizei length, const GLvoid * pointer)) \
  CONST(GL_VERTEX_ARRAY_RANGE_NV, 0x851D) \
  CONST(GL_VERTEX_ARRAY_RANGE_LENGTH_NV, 0x851E) \
  CONST(GL_VERTEX_ARRAY_RANGE_VALID_NV, 0x851F) \
  CONST(GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV, 0x8520) \
  CONST(GL_VERTEX_ARRAY_RANGE_POINTER_NV, 0x8521) \
  END()
#else
#define EXTENSION_GL_NV_vertex_array_range(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_register_combiners
#define GL_NV_register_combiners 1
#define EXTENSION_GL_NV_register_combiners(NAME, FUNC, CONST, END) \
  NAME(GL_NV_register_combiners) \
  FUNC(void, glCombinerParameterfvNV, GLCOMBINERPARAMETERFVNV, (GLenum pname, const GLfloat * params)) \
  FUNC(void, glCombinerParameterfNV, GLCOMBINERPARAMETERFNV, (GLenum pname, GLfloat param)) \
  FUNC(void, glCombinerParameterivNV, GLCOMBINERPARAMETERIVNV, (GLenum pname, const GLint * params)) \
  FUNC(void, glCombinerParameteriNV, GLCOMBINERPARAMETERINV, (GLenum pname, GLint param)) \
  FUNC(void, glCombinerInputNV, GLCOMBINERINPUTNV, (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)) \
  FUNC(void, glCombinerOutputNV, GLCOMBINEROUTPUTNV, (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)) \
  FUNC(void, glFinalCombinerInputNV, GLFINALCOMBINERINPUTNV, (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)) \
  FUNC(void, glGetCombinerInputParameterfvNV, GLGETCOMBINERINPUTPARAMETERFVNV, (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetCombinerInputParameterivNV, GLGETCOMBINERINPUTPARAMETERIVNV, (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params)) \
  FUNC(void, glGetCombinerOutputParameterfvNV, GLGETCOMBINEROUTPUTPARAMETERFVNV, (GLenum stage, GLenum portion, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetCombinerOutputParameterivNV, GLGETCOMBINEROUTPUTPARAMETERIVNV, (GLenum stage, GLenum portion, GLenum pname, GLint * params)) \
  FUNC(void, glGetFinalCombinerInputParameterfvNV, GLGETFINALCOMBINERINPUTPARAMETERFVNV, (GLenum variable, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetFinalCombinerInputParameterivNV, GLGETFINALCOMBINERINPUTPARAMETERIVNV, (GLenum variable, GLenum pname, GLint * params)) \
  CONST(GL_REGISTER_COMBINERS_NV, 0x8522) \
  CONST(GL_VARIABLE_A_NV, 0x8523) \
  CONST(GL_VARIABLE_B_NV, 0x8524) \
  CONST(GL_VARIABLE_C_NV, 0x8525) \
  CONST(GL_VARIABLE_D_NV, 0x8526) \
  CONST(GL_VARIABLE_E_NV, 0x8527) \
  CONST(GL_VARIABLE_F_NV, 0x8528) \
  CONST(GL_VARIABLE_G_NV, 0x8529) \
  CONST(GL_CONSTANT_COLOR0_NV, 0x852A) \
  CONST(GL_CONSTANT_COLOR1_NV, 0x852B) \
  CONST(GL_PRIMARY_COLOR_NV, 0x852C) \
  CONST(GL_SECONDARY_COLOR_NV, 0x852D) \
  CONST(GL_SPARE0_NV, 0x852E) \
  CONST(GL_SPARE1_NV, 0x852F) \
  CONST(GL_DISCARD_NV, 0x8530) \
  CONST(GL_E_TIMES_F_NV, 0x8531) \
  CONST(GL_SPARE0_PLUS_SECONDARY_COLOR_NV, 0x8532) \
  CONST(GL_UNSIGNED_IDENTITY_NV, 0x8536) \
  CONST(GL_UNSIGNED_INVERT_NV, 0x8537) \
  CONST(GL_EXPAND_NORMAL_NV, 0x8538) \
  CONST(GL_EXPAND_NEGATE_NV, 0x8539) \
  CONST(GL_HALF_BIAS_NORMAL_NV, 0x853A) \
  CONST(GL_HALF_BIAS_NEGATE_NV, 0x853B) \
  CONST(GL_SIGNED_IDENTITY_NV, 0x853C) \
  CONST(GL_SIGNED_NEGATE_NV, 0x853D) \
  CONST(GL_SCALE_BY_TWO_NV, 0x853E) \
  CONST(GL_SCALE_BY_FOUR_NV, 0x853F) \
  CONST(GL_SCALE_BY_ONE_HALF_NV, 0x8540) \
  CONST(GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, 0x8541) \
  CONST(GL_COMBINER_INPUT_NV, 0x8542) \
  CONST(GL_COMBINER_MAPPING_NV, 0x8543) \
  CONST(GL_COMBINER_COMPONENT_USAGE_NV, 0x8544) \
  CONST(GL_COMBINER_AB_DOT_PRODUCT_NV, 0x8545) \
  CONST(GL_COMBINER_CD_DOT_PRODUCT_NV, 0x8546) \
  CONST(GL_COMBINER_MUX_SUM_NV, 0x8547) \
  CONST(GL_COMBINER_SCALE_NV, 0x8548) \
  CONST(GL_COMBINER_BIAS_NV, 0x8549) \
  CONST(GL_COMBINER_AB_OUTPUT_NV, 0x854A) \
  CONST(GL_COMBINER_CD_OUTPUT_NV, 0x854B) \
  CONST(GL_COMBINER_SUM_OUTPUT_NV, 0x854C) \
  CONST(GL_MAX_GENERAL_COMBINERS_NV, 0x854D) \
  CONST(GL_NUM_GENERAL_COMBINERS_NV, 0x854E) \
  CONST(GL_COLOR_SUM_CLAMP_NV, 0x854F) \
  CONST(GL_COMBINER0_NV, 0x8550) \
  CONST(GL_COMBINER1_NV, 0x8551) \
  CONST(GL_COMBINER2_NV, 0x8552) \
  CONST(GL_COMBINER3_NV, 0x8553) \
  CONST(GL_COMBINER4_NV, 0x8554) \
  CONST(GL_COMBINER5_NV, 0x8555) \
  CONST(GL_COMBINER6_NV, 0x8556) \
  CONST(GL_COMBINER7_NV, 0x8557) \
  END()
#else
#define EXTENSION_GL_NV_register_combiners(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_fog_distance
#define GL_NV_fog_distance 1
#define EXTENSION_GL_NV_fog_distance(NAME, FUNC, CONST, END) \
  NAME(GL_NV_fog_distance) \
  CONST(GL_FOG_DISTANCE_MODE_NV, 0x855A) \
  CONST(GL_EYE_RADIAL_NV, 0x855B) \
  CONST(GL_EYE_PLANE_ABSOLUTE_NV, 0x855C) \
  END()
#else
#define EXTENSION_GL_NV_fog_distance(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texgen_emboss
#define GL_NV_texgen_emboss 1
#define EXTENSION_GL_NV_texgen_emboss(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texgen_emboss) \
  CONST(GL_EMBOSS_LIGHT_NV, 0x855D) \
  CONST(GL_EMBOSS_CONSTANT_NV, 0x855E) \
  CONST(GL_EMBOSS_MAP_NV, 0x855F) \
  END()
#else
#define EXTENSION_GL_NV_texgen_emboss(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_blend_square
#define GL_NV_blend_square 1
#define EXTENSION_GL_NV_blend_square(NAME, FUNC, CONST, END) \
  NAME(GL_NV_blend_square) \
  END()
#else
#define EXTENSION_GL_NV_blend_square(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texture_env_combine4
#define GL_NV_texture_env_combine4 1
#define EXTENSION_GL_NV_texture_env_combine4(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texture_env_combine4) \
  CONST(GL_COMBINE4_NV, 0x8503) \
  CONST(GL_SOURCE3_RGB_NV, 0x8583) \
  CONST(GL_SOURCE3_ALPHA_NV, 0x858B) \
  CONST(GL_OPERAND3_RGB_NV, 0x8593) \
  CONST(GL_OPERAND3_ALPHA_NV, 0x859B) \
  END()
#else
#define EXTENSION_GL_NV_texture_env_combine4(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_MESA_resize_buffers
#define GL_MESA_resize_buffers 1
#define EXTENSION_GL_MESA_resize_buffers(NAME, FUNC, CONST, END) \
  NAME(GL_MESA_resize_buffers) \
  FUNC(void, glResizeBuffersMESA, GLRESIZEBUFFERSMESA, ()) \
  END()
#else
#define EXTENSION_GL_MESA_resize_buffers(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_MESA_window_pos
#define GL_MESA_window_pos 1
#define EXTENSION_GL_MESA_window_pos(NAME, FUNC, CONST, END) \
  NAME(GL_MESA_window_pos) \
  FUNC(void, glWindowPos2dMESA, GLWINDOWPOS2DMESA, (GLdouble x, GLdouble y)) \
  FUNC(void, glWindowPos2dvMESA, GLWINDOWPOS2DVMESA, (const GLdouble * v)) \
  FUNC(void, glWindowPos2fMESA, GLWINDOWPOS2FMESA, (GLfloat x, GLfloat y)) \
  FUNC(void, glWindowPos2fvMESA, GLWINDOWPOS2FVMESA, (const GLfloat * v)) \
  FUNC(void, glWindowPos2iMESA, GLWINDOWPOS2IMESA, (GLint x, GLint y)) \
  FUNC(void, glWindowPos2ivMESA, GLWINDOWPOS2IVMESA, (const GLint * v)) \
  FUNC(void, glWindowPos2sMESA, GLWINDOWPOS2SMESA, (GLshort x, GLshort y)) \
  FUNC(void, glWindowPos2svMESA, GLWINDOWPOS2SVMESA, (const GLshort * v)) \
  FUNC(void, glWindowPos3dMESA, GLWINDOWPOS3DMESA, (GLdouble x, GLdouble y, GLdouble z)) \
  FUNC(void, glWindowPos3dvMESA, GLWINDOWPOS3DVMESA, (const GLdouble * v)) \
  FUNC(void, glWindowPos3fMESA, GLWINDOWPOS3FMESA, (GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glWindowPos3fvMESA, GLWINDOWPOS3FVMESA, (const GLfloat * v)) \
  FUNC(void, glWindowPos3iMESA, GLWINDOWPOS3IMESA, (GLint x, GLint y, GLint z)) \
  FUNC(void, glWindowPos3ivMESA, GLWINDOWPOS3IVMESA, (const GLint * v)) \
  FUNC(void, glWindowPos3sMESA, GLWINDOWPOS3SMESA, (GLshort x, GLshort y, GLshort z)) \
  FUNC(void, glWindowPos3svMESA, GLWINDOWPOS3SVMESA, (const GLshort * v)) \
  FUNC(void, glWindowPos4dMESA, GLWINDOWPOS4DMESA, (GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glWindowPos4dvMESA, GLWINDOWPOS4DVMESA, (const GLdouble * v)) \
  FUNC(void, glWindowPos4fMESA, GLWINDOWPOS4FMESA, (GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glWindowPos4fvMESA, GLWINDOWPOS4FVMESA, (const GLfloat * v)) \
  FUNC(void, glWindowPos4iMESA, GLWINDOWPOS4IMESA, (GLint x, GLint y, GLint z, GLint w)) \
  FUNC(void, glWindowPos4ivMESA, GLWINDOWPOS4IVMESA, (const GLint * v)) \
  FUNC(void, glWindowPos4sMESA, GLWINDOWPOS4SMESA, (GLshort x, GLshort y, GLshort z, GLshort w)) \
  FUNC(void, glWindowPos4svMESA, GLWINDOWPOS4SVMESA, (const GLshort * v)) \
  END()
#else
#define EXTENSION_GL_MESA_window_pos(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_compression_s3tc
#define GL_EXT_texture_compression_s3tc 1
#define EXTENSION_GL_EXT_texture_compression_s3tc(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_compression_s3tc) \
  CONST(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0x83F0) \
  CONST(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0x83F1) \
  CONST(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0x83F2) \
  CONST(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0x83F3) \
  END()
#else
#define EXTENSION_GL_EXT_texture_compression_s3tc(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_IBM_cull_vertex
#define GL_IBM_cull_vertex 1
#define EXTENSION_GL_IBM_cull_vertex(NAME, FUNC, CONST, END) \
  NAME(GL_IBM_cull_vertex) \
  CONST(GL_CULL_VERTEX_IBM, 103050) \
  END()
#else
#define EXTENSION_GL_IBM_cull_vertex(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_IBM_multimode_draw_arrays
#define GL_IBM_multimode_draw_arrays 1
#define EXTENSION_GL_IBM_multimode_draw_arrays(NAME, FUNC, CONST, END) \
  NAME(GL_IBM_multimode_draw_arrays) \
  FUNC(void, glMultiModeDrawArraysIBM, GLMULTIMODEDRAWARRAYSIBM, (const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)) \
  FUNC(void, glMultiModeDrawElementsIBM, GLMULTIMODEDRAWELEMENTSIBM, (const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid* const * indices, GLsizei primcount, GLint modestride)) \
  END()
#else
#define EXTENSION_GL_IBM_multimode_draw_arrays(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_IBM_vertex_array_lists
#define GL_IBM_vertex_array_lists 1
#define EXTENSION_GL_IBM_vertex_array_lists(NAME, FUNC, CONST, END) \
  NAME(GL_IBM_vertex_array_lists) \
  FUNC(void, glColorPointerListIBM, GLCOLORPOINTERLISTIBM, (GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)) \
  FUNC(void, glSecondaryColorPointerListIBM, GLSECONDARYCOLORPOINTERLISTIBM, (GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)) \
  FUNC(void, glEdgeFlagPointerListIBM, GLEDGEFLAGPOINTERLISTIBM, (GLint stride, const GLboolean* * pointer, GLint ptrstride)) \
  FUNC(void, glFogCoordPointerListIBM, GLFOGCOORDPOINTERLISTIBM, (GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)) \
  FUNC(void, glIndexPointerListIBM, GLINDEXPOINTERLISTIBM, (GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)) \
  FUNC(void, glNormalPointerListIBM, GLNORMALPOINTERLISTIBM, (GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)) \
  FUNC(void, glTexCoordPointerListIBM, GLTEXCOORDPOINTERLISTIBM, (GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)) \
  FUNC(void, glVertexPointerListIBM, GLVERTEXPOINTERLISTIBM, (GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)) \
  CONST(GL_VERTEX_ARRAY_LIST_IBM, 103070) \
  CONST(GL_NORMAL_ARRAY_LIST_IBM, 103071) \
  CONST(GL_COLOR_ARRAY_LIST_IBM, 103072) \
  CONST(GL_INDEX_ARRAY_LIST_IBM, 103073) \
  CONST(GL_TEXTURE_COORD_ARRAY_LIST_IBM, 103074) \
  CONST(GL_EDGE_FLAG_ARRAY_LIST_IBM, 103075) \
  CONST(GL_FOG_COORDINATE_ARRAY_LIST_IBM, 103076) \
  CONST(GL_SECONDARY_COLOR_ARRAY_LIST_IBM, 103077) \
  CONST(GL_VERTEX_ARRAY_LIST_STRIDE_IBM, 103080) \
  CONST(GL_NORMAL_ARRAY_LIST_STRIDE_IBM, 103081) \
  CONST(GL_COLOR_ARRAY_LIST_STRIDE_IBM, 103082) \
  CONST(GL_INDEX_ARRAY_LIST_STRIDE_IBM, 103083) \
  CONST(GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM, 103084) \
  CONST(GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM, 103085) \
  CONST(GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM, 103086) \
  CONST(GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM, 103087) \
  END()
#else
#define EXTENSION_GL_IBM_vertex_array_lists(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_subsample
#define GL_SGIX_subsample 1
#define EXTENSION_GL_SGIX_subsample(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_subsample) \
  CONST(GL_PACK_SUBSAMPLE_RATE_SGIX, 0x85A0) \
  CONST(GL_UNPACK_SUBSAMPLE_RATE_SGIX, 0x85A1) \
  CONST(GL_PIXEL_SUBSAMPLE_4444_SGIX, 0x85A2) \
  CONST(GL_PIXEL_SUBSAMPLE_2424_SGIX, 0x85A3) \
  CONST(GL_PIXEL_SUBSAMPLE_4242_SGIX, 0x85A4) \
  END()
#else
#define EXTENSION_GL_SGIX_subsample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_ycrcb_subsample
#define GL_SGIX_ycrcb_subsample 1
#define EXTENSION_GL_SGIX_ycrcb_subsample(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_ycrcb_subsample) \
  END()
#else
#define EXTENSION_GL_SGIX_ycrcb_subsample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_ycrcba
#define GL_SGIX_ycrcba 1
#define EXTENSION_GL_SGIX_ycrcba(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_ycrcba) \
  CONST(GL_YCRCB_SGIX, 0x8318) \
  CONST(GL_YCRCBA_SGIX, 0x8319) \
  END()
#else
#define EXTENSION_GL_SGIX_ycrcba(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGI_depth_pass_instrument
#define GL_SGI_depth_pass_instrument 1
#define EXTENSION_GL_SGI_depth_pass_instrument(NAME, FUNC, CONST, END) \
  NAME(GL_SGI_depth_pass_instrument) \
  CONST(GL_DEPTH_PASS_INSTRUMENT_SGIX, 0x8310) \
  CONST(GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX, 0x8311) \
  CONST(GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX, 0x8312) \
  END()
#else
#define EXTENSION_GL_SGI_depth_pass_instrument(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_3DFX_texture_compression_FXT1
#define GL_3DFX_texture_compression_FXT1 1
#define EXTENSION_GL_3DFX_texture_compression_FXT1(NAME, FUNC, CONST, END) \
  NAME(GL_3DFX_texture_compression_FXT1) \
  CONST(GL_COMPRESSED_RGB_FXT1_3DFX, 0x86B0) \
  CONST(GL_COMPRESSED_RGBA_FXT1_3DFX, 0x86B1) \
  END()
#else
#define EXTENSION_GL_3DFX_texture_compression_FXT1(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_3DFX_multisample
#define GL_3DFX_multisample 1
#define EXTENSION_GL_3DFX_multisample(NAME, FUNC, CONST, END) \
  NAME(GL_3DFX_multisample) \
  CONST(GL_MULTISAMPLE_3DFX, 0x86B2) \
  CONST(GL_SAMPLE_BUFFERS_3DFX, 0x86B3) \
  CONST(GL_SAMPLES_3DFX, 0x86B4) \
  CONST(GL_MULTISAMPLE_BIT_3DFX, 0x20000000) \
  END()
#else
#define EXTENSION_GL_3DFX_multisample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_3DFX_tbuffer
#define GL_3DFX_tbuffer 1
#define EXTENSION_GL_3DFX_tbuffer(NAME, FUNC, CONST, END) \
  NAME(GL_3DFX_tbuffer) \
  FUNC(void, glTbufferMask3DFX, GLTBUFFERMASK3DFX, (GLuint mask)) \
  END()
#else
#define EXTENSION_GL_3DFX_tbuffer(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_multisample
#define GL_EXT_multisample 1
#define EXTENSION_GL_EXT_multisample(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_multisample) \
  FUNC(void, glSampleMaskEXT, GLSAMPLEMASKEXT, (GLclampf value, GLboolean invert)) \
  FUNC(void, glSamplePatternEXT, GLSAMPLEPATTERNEXT, (GLenum pattern)) \
  CONST(GL_MULTISAMPLE_EXT, 0x809D) \
  CONST(GL_SAMPLE_ALPHA_TO_MASK_EXT, 0x809E) \
  CONST(GL_SAMPLE_ALPHA_TO_ONE_EXT, 0x809F) \
  CONST(GL_SAMPLE_MASK_EXT, 0x80A0) \
  CONST(GL_1PASS_EXT, 0x80A1) \
  CONST(GL_2PASS_0_EXT, 0x80A2) \
  CONST(GL_2PASS_1_EXT, 0x80A3) \
  CONST(GL_4PASS_0_EXT, 0x80A4) \
  CONST(GL_4PASS_1_EXT, 0x80A5) \
  CONST(GL_4PASS_2_EXT, 0x80A6) \
  CONST(GL_4PASS_3_EXT, 0x80A7) \
  CONST(GL_SAMPLE_BUFFERS_EXT, 0x80A8) \
  CONST(GL_SAMPLES_EXT, 0x80A9) \
  CONST(GL_SAMPLE_MASK_VALUE_EXT, 0x80AA) \
  CONST(GL_SAMPLE_MASK_INVERT_EXT, 0x80AB) \
  CONST(GL_SAMPLE_PATTERN_EXT, 0x80AC) \
  CONST(GL_MULTISAMPLE_BIT_EXT, 0x20000000) \
  END()
#else
#define EXTENSION_GL_EXT_multisample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_vertex_preclip
#define GL_SGIX_vertex_preclip 1
#define EXTENSION_GL_SGIX_vertex_preclip(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_vertex_preclip) \
  CONST(GL_VERTEX_PRECLIP_SGIX, 0x83EE) \
  CONST(GL_VERTEX_PRECLIP_HINT_SGIX, 0x83EF) \
  END()
#else
#define EXTENSION_GL_SGIX_vertex_preclip(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_convolution_accuracy
#define GL_SGIX_convolution_accuracy 1
#define EXTENSION_GL_SGIX_convolution_accuracy(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_convolution_accuracy) \
  CONST(GL_CONVOLUTION_HINT_SGIX, 0x8316) \
  END()
#else
#define EXTENSION_GL_SGIX_convolution_accuracy(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_resample
#define GL_SGIX_resample 1
#define EXTENSION_GL_SGIX_resample(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_resample) \
  CONST(GL_PACK_RESAMPLE_SGIX, 0x842C) \
  CONST(GL_UNPACK_RESAMPLE_SGIX, 0x842D) \
  CONST(GL_RESAMPLE_REPLICATE_SGIX, 0x842E) \
  CONST(GL_RESAMPLE_ZERO_FILL_SGIX, 0x842F) \
  CONST(GL_RESAMPLE_DECIMATE_SGIX, 0x8430) \
  END()
#else
#define EXTENSION_GL_SGIX_resample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_point_line_texgen
#define GL_SGIS_point_line_texgen 1
#define EXTENSION_GL_SGIS_point_line_texgen(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_point_line_texgen) \
  CONST(GL_EYE_DISTANCE_TO_POINT_SGIS, 0x81F0) \
  CONST(GL_OBJECT_DISTANCE_TO_POINT_SGIS, 0x81F1) \
  CONST(GL_EYE_DISTANCE_TO_LINE_SGIS, 0x81F2) \
  CONST(GL_OBJECT_DISTANCE_TO_LINE_SGIS, 0x81F3) \
  CONST(GL_EYE_POINT_SGIS, 0x81F4) \
  CONST(GL_OBJECT_POINT_SGIS, 0x81F5) \
  CONST(GL_EYE_LINE_SGIS, 0x81F6) \
  CONST(GL_OBJECT_LINE_SGIS, 0x81F7) \
  END()
#else
#define EXTENSION_GL_SGIS_point_line_texgen(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIS_texture_color_mask
#define GL_SGIS_texture_color_mask 1
#define EXTENSION_GL_SGIS_texture_color_mask(NAME, FUNC, CONST, END) \
  NAME(GL_SGIS_texture_color_mask) \
  FUNC(void, glTextureColorMaskSGIS, GLTEXTURECOLORMASKSGIS, (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)) \
  CONST(GL_TEXTURE_COLOR_WRITEMASK_SGIS, 0x81EF) \
  END()
#else
#define EXTENSION_GL_SGIS_texture_color_mask(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_env_dot3
#define GL_EXT_texture_env_dot3 1
#define EXTENSION_GL_EXT_texture_env_dot3(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_env_dot3) \
  CONST(GL_DOT3_RGB_EXT, 0x8740) \
  CONST(GL_DOT3_RGBA_EXT, 0x8741) \
  END()
#else
#define EXTENSION_GL_EXT_texture_env_dot3(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_texture_mirror_once
#define GL_ATI_texture_mirror_once 1
#define EXTENSION_GL_ATI_texture_mirror_once(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_texture_mirror_once) \
  CONST(GL_MIRROR_CLAMP_ATI, 0x8742) \
  CONST(GL_MIRROR_CLAMP_TO_EDGE_ATI, 0x8743) \
  END()
#else
#define EXTENSION_GL_ATI_texture_mirror_once(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_fence
#define GL_NV_fence 1
#define EXTENSION_GL_NV_fence(NAME, FUNC, CONST, END) \
  NAME(GL_NV_fence) \
  FUNC(void, glDeleteFencesNV, GLDELETEFENCESNV, (GLsizei n, const GLuint * fences)) \
  FUNC(void, glGenFencesNV, GLGENFENCESNV, (GLsizei n, GLuint * fences)) \
  FUNC(GLboolean, glIsFenceNV, GLISFENCENV, (GLuint fence)) \
  FUNC(GLboolean, glTestFenceNV, GLTESTFENCENV, (GLuint fence)) \
  FUNC(void, glGetFenceivNV, GLGETFENCEIVNV, (GLuint fence, GLenum pname, GLint * params)) \
  FUNC(void, glFinishFenceNV, GLFINISHFENCENV, (GLuint fence)) \
  FUNC(void, glSetFenceNV, GLSETFENCENV, (GLuint fence, GLenum condition)) \
  CONST(GL_ALL_COMPLETED_NV, 0x84F2) \
  CONST(GL_FENCE_STATUS_NV, 0x84F3) \
  CONST(GL_FENCE_CONDITION_NV, 0x84F4) \
  END()
#else
#define EXTENSION_GL_NV_fence(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_IBM_texture_mirrored_repeat
#define GL_IBM_texture_mirrored_repeat 1
#define EXTENSION_GL_IBM_texture_mirrored_repeat(NAME, FUNC, CONST, END) \
  NAME(GL_IBM_texture_mirrored_repeat) \
  CONST(GL_MIRRORED_REPEAT_IBM, 0x8370) \
  END()
#else
#define EXTENSION_GL_IBM_texture_mirrored_repeat(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_evaluators
#define GL_NV_evaluators 1
#define EXTENSION_GL_NV_evaluators(NAME, FUNC, CONST, END) \
  NAME(GL_NV_evaluators) \
  FUNC(void, glMapControlPointsNV, GLMAPCONTROLPOINTSNV, (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid * points)) \
  FUNC(void, glMapParameterivNV, GLMAPPARAMETERIVNV, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glMapParameterfvNV, GLMAPPARAMETERFVNV, (GLenum target, GLenum pname, const GLfloat * params)) \
  FUNC(void, glGetMapControlPointsNV, GLGETMAPCONTROLPOINTSNV, (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid * points)) \
  FUNC(void, glGetMapParameterivNV, GLGETMAPPARAMETERIVNV, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetMapParameterfvNV, GLGETMAPPARAMETERFVNV, (GLenum target, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetMapAttribParameterivNV, GLGETMAPATTRIBPARAMETERIVNV, (GLenum target, GLuint index, GLenum pname, GLint * params)) \
  FUNC(void, glGetMapAttribParameterfvNV, GLGETMAPATTRIBPARAMETERFVNV, (GLenum target, GLuint index, GLenum pname, GLfloat * params)) \
  FUNC(void, glEvalMapsNV, GLEVALMAPSNV, (GLenum target, GLenum mode)) \
  CONST(GL_EVAL_2D_NV, 0x86C0) \
  CONST(GL_EVAL_TRIANGULAR_2D_NV, 0x86C1) \
  CONST(GL_MAP_TESSELLATION_NV, 0x86C2) \
  CONST(GL_MAP_ATTRIB_U_ORDER_NV, 0x86C3) \
  CONST(GL_MAP_ATTRIB_V_ORDER_NV, 0x86C4) \
  CONST(GL_EVAL_FRACTIONAL_TESSELLATION_NV, 0x86C5) \
  CONST(GL_EVAL_VERTEX_ATTRIB0_NV, 0x86C6) \
  CONST(GL_EVAL_VERTEX_ATTRIB1_NV, 0x86C7) \
  CONST(GL_EVAL_VERTEX_ATTRIB2_NV, 0x86C8) \
  CONST(GL_EVAL_VERTEX_ATTRIB3_NV, 0x86C9) \
  CONST(GL_EVAL_VERTEX_ATTRIB4_NV, 0x86CA) \
  CONST(GL_EVAL_VERTEX_ATTRIB5_NV, 0x86CB) \
  CONST(GL_EVAL_VERTEX_ATTRIB6_NV, 0x86CC) \
  CONST(GL_EVAL_VERTEX_ATTRIB7_NV, 0x86CD) \
  CONST(GL_EVAL_VERTEX_ATTRIB8_NV, 0x86CE) \
  CONST(GL_EVAL_VERTEX_ATTRIB9_NV, 0x86CF) \
  CONST(GL_EVAL_VERTEX_ATTRIB10_NV, 0x86D0) \
  CONST(GL_EVAL_VERTEX_ATTRIB11_NV, 0x86D1) \
  CONST(GL_EVAL_VERTEX_ATTRIB12_NV, 0x86D2) \
  CONST(GL_EVAL_VERTEX_ATTRIB13_NV, 0x86D3) \
  CONST(GL_EVAL_VERTEX_ATTRIB14_NV, 0x86D4) \
  CONST(GL_EVAL_VERTEX_ATTRIB15_NV, 0x86D5) \
  CONST(GL_MAX_MAP_TESSELLATION_NV, 0x86D6) \
  CONST(GL_MAX_RATIONAL_EVAL_ORDER_NV, 0x86D7) \
  END()
#else
#define EXTENSION_GL_NV_evaluators(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_packed_depth_stencil
#define GL_NV_packed_depth_stencil 1
#define EXTENSION_GL_NV_packed_depth_stencil(NAME, FUNC, CONST, END) \
  NAME(GL_NV_packed_depth_stencil) \
  CONST(GL_DEPTH_STENCIL_NV, 0x84F9) \
  CONST(GL_UNSIGNED_INT_24_8_NV, 0x84FA) \
  END()
#else
#define EXTENSION_GL_NV_packed_depth_stencil(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_register_combiners2
#define GL_NV_register_combiners2 1
#define EXTENSION_GL_NV_register_combiners2(NAME, FUNC, CONST, END) \
  NAME(GL_NV_register_combiners2) \
  FUNC(void, glCombinerStageParameterfvNV, GLCOMBINERSTAGEPARAMETERFVNV, (GLenum stage, GLenum pname, const GLfloat * params)) \
  FUNC(void, glGetCombinerStageParameterfvNV, GLGETCOMBINERSTAGEPARAMETERFVNV, (GLenum stage, GLenum pname, GLfloat * params)) \
  CONST(GL_PER_STAGE_CONSTANTS_NV, 0x8535) \
  END()
#else
#define EXTENSION_GL_NV_register_combiners2(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texture_compression_vtc
#define GL_NV_texture_compression_vtc 1
#define EXTENSION_GL_NV_texture_compression_vtc(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texture_compression_vtc) \
  END()
#else
#define EXTENSION_GL_NV_texture_compression_vtc(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texture_rectangle
#define GL_NV_texture_rectangle 1
#define EXTENSION_GL_NV_texture_rectangle(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texture_rectangle) \
  CONST(GL_TEXTURE_RECTANGLE_NV, 0x84F5) \
  CONST(GL_TEXTURE_BINDING_RECTANGLE_NV, 0x84F6) \
  CONST(GL_PROXY_TEXTURE_RECTANGLE_NV, 0x84F7) \
  CONST(GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, 0x84F8) \
  END()
#else
#define EXTENSION_GL_NV_texture_rectangle(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texture_shader
#define GL_NV_texture_shader 1
#define EXTENSION_GL_NV_texture_shader(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texture_shader) \
  CONST(GL_OFFSET_TEXTURE_RECTANGLE_NV, 0x864C) \
  CONST(GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV, 0x864D) \
  CONST(GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV, 0x864E) \
  CONST(GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, 0x86D9) \
  CONST(GL_UNSIGNED_INT_S8_S8_8_8_NV, 0x86DA) \
  CONST(GL_UNSIGNED_INT_8_8_S8_S8_REV_NV, 0x86DB) \
  CONST(GL_DSDT_MAG_INTENSITY_NV, 0x86DC) \
  CONST(GL_SHADER_CONSISTENT_NV, 0x86DD) \
  CONST(GL_TEXTURE_SHADER_NV, 0x86DE) \
  CONST(GL_SHADER_OPERATION_NV, 0x86DF) \
  CONST(GL_CULL_MODES_NV, 0x86E0) \
  CONST(GL_OFFSET_TEXTURE_MATRIX_NV, 0x86E1) \
  CONST(GL_OFFSET_TEXTURE_SCALE_NV, 0x86E2) \
  CONST(GL_OFFSET_TEXTURE_BIAS_NV, 0x86E3) \
  CONST(GL_OFFSET_TEXTURE_2D_MATRIX_NV, GL_OFFSET_TEXTURE_MATRIX_NV) \
  CONST(GL_OFFSET_TEXTURE_2D_SCALE_NV, GL_OFFSET_TEXTURE_SCALE_NV) \
  CONST(GL_OFFSET_TEXTURE_2D_BIAS_NV, GL_OFFSET_TEXTURE_BIAS_NV) \
  CONST(GL_PREVIOUS_TEXTURE_INPUT_NV, 0x86E4) \
  CONST(GL_CONST_EYE_NV, 0x86E5) \
  CONST(GL_PASS_THROUGH_NV, 0x86E6) \
  CONST(GL_CULL_FRAGMENT_NV, 0x86E7) \
  CONST(GL_OFFSET_TEXTURE_2D_NV, 0x86E8) \
  CONST(GL_DEPENDENT_AR_TEXTURE_2D_NV, 0x86E9) \
  CONST(GL_DEPENDENT_GB_TEXTURE_2D_NV, 0x86EA) \
  CONST(GL_DOT_PRODUCT_NV, 0x86EC) \
  CONST(GL_DOT_PRODUCT_DEPTH_REPLACE_NV, 0x86ED) \
  CONST(GL_DOT_PRODUCT_TEXTURE_2D_NV, 0x86EE) \
  CONST(GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, 0x86F0) \
  CONST(GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, 0x86F1) \
  CONST(GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV, 0x86F2) \
  CONST(GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV, 0x86F3) \
  CONST(GL_HILO_NV, 0x86F4) \
  CONST(GL_DSDT_NV, 0x86F5) \
  CONST(GL_DSDT_MAG_NV, 0x86F6) \
  CONST(GL_DSDT_MAG_VIB_NV, 0x86F7) \
  CONST(GL_HILO16_NV, 0x86F8) \
  CONST(GL_SIGNED_HILO_NV, 0x86F9) \
  CONST(GL_SIGNED_HILO16_NV, 0x86FA) \
  CONST(GL_SIGNED_RGBA_NV, 0x86FB) \
  CONST(GL_SIGNED_RGBA8_NV, 0x86FC) \
  CONST(GL_SIGNED_RGB_NV, 0x86FE) \
  CONST(GL_SIGNED_RGB8_NV, 0x86FF) \
  CONST(GL_SIGNED_LUMINANCE_NV, 0x8701) \
  CONST(GL_SIGNED_LUMINANCE8_NV, 0x8702) \
  CONST(GL_SIGNED_LUMINANCE_ALPHA_NV, 0x8703) \
  CONST(GL_SIGNED_LUMINANCE8_ALPHA8_NV, 0x8704) \
  CONST(GL_SIGNED_ALPHA_NV, 0x8705) \
  CONST(GL_SIGNED_ALPHA8_NV, 0x8706) \
  CONST(GL_SIGNED_INTENSITY_NV, 0x8707) \
  CONST(GL_SIGNED_INTENSITY8_NV, 0x8708) \
  CONST(GL_DSDT8_NV, 0x8709) \
  CONST(GL_DSDT8_MAG8_NV, 0x870A) \
  CONST(GL_DSDT8_MAG8_INTENSITY8_NV, 0x870B) \
  CONST(GL_SIGNED_RGB_UNSIGNED_ALPHA_NV, 0x870C) \
  CONST(GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV, 0x870D) \
  CONST(GL_HI_SCALE_NV, 0x870E) \
  CONST(GL_LO_SCALE_NV, 0x870F) \
  CONST(GL_DS_SCALE_NV, 0x8710) \
  CONST(GL_DT_SCALE_NV, 0x8711) \
  CONST(GL_MAGNITUDE_SCALE_NV, 0x8712) \
  CONST(GL_VIBRANCE_SCALE_NV, 0x8713) \
  CONST(GL_HI_BIAS_NV, 0x8714) \
  CONST(GL_LO_BIAS_NV, 0x8715) \
  CONST(GL_DS_BIAS_NV, 0x8716) \
  CONST(GL_DT_BIAS_NV, 0x8717) \
  CONST(GL_MAGNITUDE_BIAS_NV, 0x8718) \
  CONST(GL_VIBRANCE_BIAS_NV, 0x8719) \
  CONST(GL_TEXTURE_BORDER_VALUES_NV, 0x871A) \
  CONST(GL_TEXTURE_HI_SIZE_NV, 0x871B) \
  CONST(GL_TEXTURE_LO_SIZE_NV, 0x871C) \
  CONST(GL_TEXTURE_DS_SIZE_NV, 0x871D) \
  CONST(GL_TEXTURE_DT_SIZE_NV, 0x871E) \
  CONST(GL_TEXTURE_MAG_SIZE_NV, 0x871F) \
  END()
#else
#define EXTENSION_GL_NV_texture_shader(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texture_shader2
#define GL_NV_texture_shader2 1
#define EXTENSION_GL_NV_texture_shader2(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texture_shader2) \
  CONST(GL_DOT_PRODUCT_TEXTURE_3D_NV, 0x86EF) \
  END()
#else
#define EXTENSION_GL_NV_texture_shader2(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_vertex_array_range2
#define GL_NV_vertex_array_range2 1
#define EXTENSION_GL_NV_vertex_array_range2(NAME, FUNC, CONST, END) \
  NAME(GL_NV_vertex_array_range2) \
  CONST(GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV, 0x8533) \
  END()
#else
#define EXTENSION_GL_NV_vertex_array_range2(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_vertex_program
#define GL_NV_vertex_program 1
#define EXTENSION_GL_NV_vertex_program(NAME, FUNC, CONST, END) \
  NAME(GL_NV_vertex_program) \
  FUNC(GLboolean, glAreProgramsResidentNV, GLAREPROGRAMSRESIDENTNV, (GLsizei n, const GLuint * programs, GLboolean * residences)) \
  FUNC(void, glBindProgramNV, GLBINDPROGRAMNV, (GLenum target, GLuint id)) \
  FUNC(void, glDeleteProgramsNV, GLDELETEPROGRAMSNV, (GLsizei n, const GLuint * programs)) \
  FUNC(void, glExecuteProgramNV, GLEXECUTEPROGRAMNV, (GLenum target, GLuint id, const GLfloat * params)) \
  FUNC(void, glGenProgramsNV, GLGENPROGRAMSNV, (GLsizei n, GLuint * programs)) \
  FUNC(void, glGetProgramParameterdvNV, GLGETPROGRAMPARAMETERDVNV, (GLenum target, GLuint index, GLenum pname, GLdouble * params)) \
  FUNC(void, glGetProgramParameterfvNV, GLGETPROGRAMPARAMETERFVNV, (GLenum target, GLuint index, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetProgramivNV, GLGETPROGRAMIVNV, (GLuint id, GLenum pname, GLint * params)) \
  FUNC(void, glGetProgramStringNV, GLGETPROGRAMSTRINGNV, (GLuint id, GLenum pname, GLubyte * program)) \
  FUNC(void, glGetTrackMatrixivNV, GLGETTRACKMATRIXIVNV, (GLenum target, GLuint address, GLenum pname, GLint * params)) \
  FUNC(void, glGetVertexAttribdvNV, GLGETVERTEXATTRIBDVNV, (GLuint index, GLenum pname, GLdouble * params)) \
  FUNC(void, glGetVertexAttribfvNV, GLGETVERTEXATTRIBFVNV, (GLuint index, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetVertexAttribivNV, GLGETVERTEXATTRIBIVNV, (GLuint index, GLenum pname, GLint * params)) \
  FUNC(void, glGetVertexAttribPointervNV, GLGETVERTEXATTRIBPOINTERVNV, (GLuint index, GLenum pname, GLvoid* * pointer)) \
  FUNC(GLboolean, glIsProgramNV, GLISPROGRAMNV, (GLuint id)) \
  FUNC(void, glLoadProgramNV, GLLOADPROGRAMNV, (GLenum target, GLuint id, GLsizei len, const GLubyte * program)) \
  FUNC(void, glProgramParameter4dNV, GLPROGRAMPARAMETER4DNV, (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glProgramParameter4dvNV, GLPROGRAMPARAMETER4DVNV, (GLenum target, GLuint index, const GLdouble * v)) \
  FUNC(void, glProgramParameter4fNV, GLPROGRAMPARAMETER4FNV, (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glProgramParameter4fvNV, GLPROGRAMPARAMETER4FVNV, (GLenum target, GLuint index, const GLfloat * v)) \
  FUNC(void, glProgramParameters4dvNV, GLPROGRAMPARAMETERS4DVNV, (GLenum target, GLuint index, GLuint count, const GLdouble * v)) \
  FUNC(void, glProgramParameters4fvNV, GLPROGRAMPARAMETERS4FVNV, (GLenum target, GLuint index, GLuint count, const GLfloat * v)) \
  FUNC(void, glRequestResidentProgramsNV, GLREQUESTRESIDENTPROGRAMSNV, (GLsizei n, const GLuint * programs)) \
  FUNC(void, glTrackMatrixNV, GLTRACKMATRIXNV, (GLenum target, GLuint address, GLenum matrix, GLenum transform)) \
  FUNC(void, glVertexAttribPointerNV, GLVERTEXATTRIBPOINTERNV, (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid * pointer)) \
  FUNC(void, glVertexAttrib1dNV, GLVERTEXATTRIB1DNV, (GLuint index, GLdouble x)) \
  FUNC(void, glVertexAttrib1dvNV, GLVERTEXATTRIB1DVNV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib1fNV, GLVERTEXATTRIB1FNV, (GLuint index, GLfloat x)) \
  FUNC(void, glVertexAttrib1fvNV, GLVERTEXATTRIB1FVNV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib1sNV, GLVERTEXATTRIB1SNV, (GLuint index, GLshort x)) \
  FUNC(void, glVertexAttrib1svNV, GLVERTEXATTRIB1SVNV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib2dNV, GLVERTEXATTRIB2DNV, (GLuint index, GLdouble x, GLdouble y)) \
  FUNC(void, glVertexAttrib2dvNV, GLVERTEXATTRIB2DVNV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib2fNV, GLVERTEXATTRIB2FNV, (GLuint index, GLfloat x, GLfloat y)) \
  FUNC(void, glVertexAttrib2fvNV, GLVERTEXATTRIB2FVNV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib2sNV, GLVERTEXATTRIB2SNV, (GLuint index, GLshort x, GLshort y)) \
  FUNC(void, glVertexAttrib2svNV, GLVERTEXATTRIB2SVNV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib3dNV, GLVERTEXATTRIB3DNV, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
  FUNC(void, glVertexAttrib3dvNV, GLVERTEXATTRIB3DVNV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib3fNV, GLVERTEXATTRIB3FNV, (GLuint index, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glVertexAttrib3fvNV, GLVERTEXATTRIB3FVNV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib3sNV, GLVERTEXATTRIB3SNV, (GLuint index, GLshort x, GLshort y, GLshort z)) \
  FUNC(void, glVertexAttrib3svNV, GLVERTEXATTRIB3SVNV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4dNV, GLVERTEXATTRIB4DNV, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glVertexAttrib4dvNV, GLVERTEXATTRIB4DVNV, (GLuint index, const GLdouble * v)) \
  FUNC(void, glVertexAttrib4fNV, GLVERTEXATTRIB4FNV, (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glVertexAttrib4fvNV, GLVERTEXATTRIB4FVNV, (GLuint index, const GLfloat * v)) \
  FUNC(void, glVertexAttrib4sNV, GLVERTEXATTRIB4SNV, (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)) \
  FUNC(void, glVertexAttrib4svNV, GLVERTEXATTRIB4SVNV, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttrib4ubNV, GLVERTEXATTRIB4UBNV, (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)) \
  FUNC(void, glVertexAttrib4ubvNV, GLVERTEXATTRIB4UBVNV, (GLuint index, const GLubyte * v)) \
  FUNC(void, glVertexAttribs1dvNV, GLVERTEXATTRIBS1DVNV, (GLuint index, GLsizei count, const GLdouble * v)) \
  FUNC(void, glVertexAttribs1fvNV, GLVERTEXATTRIBS1FVNV, (GLuint index, GLsizei count, const GLfloat * v)) \
  FUNC(void, glVertexAttribs1svNV, GLVERTEXATTRIBS1SVNV, (GLuint index, GLsizei count, const GLshort * v)) \
  FUNC(void, glVertexAttribs2dvNV, GLVERTEXATTRIBS2DVNV, (GLuint index, GLsizei count, const GLdouble * v)) \
  FUNC(void, glVertexAttribs2fvNV, GLVERTEXATTRIBS2FVNV, (GLuint index, GLsizei count, const GLfloat * v)) \
  FUNC(void, glVertexAttribs2svNV, GLVERTEXATTRIBS2SVNV, (GLuint index, GLsizei count, const GLshort * v)) \
  FUNC(void, glVertexAttribs3dvNV, GLVERTEXATTRIBS3DVNV, (GLuint index, GLsizei count, const GLdouble * v)) \
  FUNC(void, glVertexAttribs3fvNV, GLVERTEXATTRIBS3FVNV, (GLuint index, GLsizei count, const GLfloat * v)) \
  FUNC(void, glVertexAttribs3svNV, GLVERTEXATTRIBS3SVNV, (GLuint index, GLsizei count, const GLshort * v)) \
  FUNC(void, glVertexAttribs4dvNV, GLVERTEXATTRIBS4DVNV, (GLuint index, GLsizei count, const GLdouble * v)) \
  FUNC(void, glVertexAttribs4fvNV, GLVERTEXATTRIBS4FVNV, (GLuint index, GLsizei count, const GLfloat * v)) \
  FUNC(void, glVertexAttribs4svNV, GLVERTEXATTRIBS4SVNV, (GLuint index, GLsizei count, const GLshort * v)) \
  FUNC(void, glVertexAttribs4ubvNV, GLVERTEXATTRIBS4UBVNV, (GLuint index, GLsizei count, const GLubyte * v)) \
  CONST(GL_VERTEX_PROGRAM_NV, 0x8620) \
  CONST(GL_VERTEX_STATE_PROGRAM_NV, 0x8621) \
  CONST(GL_ATTRIB_ARRAY_SIZE_NV, 0x8623) \
  CONST(GL_ATTRIB_ARRAY_STRIDE_NV, 0x8624) \
  CONST(GL_ATTRIB_ARRAY_TYPE_NV, 0x8625) \
  CONST(GL_CURRENT_ATTRIB_NV, 0x8626) \
  CONST(GL_PROGRAM_LENGTH_NV, 0x8627) \
  CONST(GL_PROGRAM_STRING_NV, 0x8628) \
  CONST(GL_MODELVIEW_PROJECTION_NV, 0x8629) \
  CONST(GL_IDENTITY_NV, 0x862A) \
  CONST(GL_INVERSE_NV, 0x862B) \
  CONST(GL_TRANSPOSE_NV, 0x862C) \
  CONST(GL_INVERSE_TRANSPOSE_NV, 0x862D) \
  CONST(GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV, 0x862E) \
  CONST(GL_MAX_TRACK_MATRICES_NV, 0x862F) \
  CONST(GL_MATRIX0_NV, 0x8630) \
  CONST(GL_MATRIX1_NV, 0x8631) \
  CONST(GL_MATRIX2_NV, 0x8632) \
  CONST(GL_MATRIX3_NV, 0x8633) \
  CONST(GL_MATRIX4_NV, 0x8634) \
  CONST(GL_MATRIX5_NV, 0x8635) \
  CONST(GL_MATRIX6_NV, 0x8636) \
  CONST(GL_MATRIX7_NV, 0x8637) \
  CONST(GL_CURRENT_MATRIX_STACK_DEPTH_NV, 0x8640) \
  CONST(GL_CURRENT_MATRIX_NV, 0x8641) \
  CONST(GL_VERTEX_PROGRAM_POINT_SIZE_NV, 0x8642) \
  CONST(GL_VERTEX_PROGRAM_TWO_SIDE_NV, 0x8643) \
  CONST(GL_PROGRAM_PARAMETER_NV, 0x8644) \
  CONST(GL_ATTRIB_ARRAY_POINTER_NV, 0x8645) \
  CONST(GL_PROGRAM_TARGET_NV, 0x8646) \
  CONST(GL_PROGRAM_RESIDENT_NV, 0x8647) \
  CONST(GL_TRACK_MATRIX_NV, 0x8648) \
  CONST(GL_TRACK_MATRIX_TRANSFORM_NV, 0x8649) \
  CONST(GL_VERTEX_PROGRAM_BINDING_NV, 0x864A) \
  CONST(GL_PROGRAM_ERROR_POSITION_NV, 0x864B) \
  CONST(GL_VERTEX_ATTRIB_ARRAY0_NV, 0x8650) \
  CONST(GL_VERTEX_ATTRIB_ARRAY1_NV, 0x8651) \
  CONST(GL_VERTEX_ATTRIB_ARRAY2_NV, 0x8652) \
  CONST(GL_VERTEX_ATTRIB_ARRAY3_NV, 0x8653) \
  CONST(GL_VERTEX_ATTRIB_ARRAY4_NV, 0x8654) \
  CONST(GL_VERTEX_ATTRIB_ARRAY5_NV, 0x8655) \
  CONST(GL_VERTEX_ATTRIB_ARRAY6_NV, 0x8656) \
  CONST(GL_VERTEX_ATTRIB_ARRAY7_NV, 0x8657) \
  CONST(GL_VERTEX_ATTRIB_ARRAY8_NV, 0x8658) \
  CONST(GL_VERTEX_ATTRIB_ARRAY9_NV, 0x8659) \
  CONST(GL_VERTEX_ATTRIB_ARRAY10_NV, 0x865A) \
  CONST(GL_VERTEX_ATTRIB_ARRAY11_NV, 0x865B) \
  CONST(GL_VERTEX_ATTRIB_ARRAY12_NV, 0x865C) \
  CONST(GL_VERTEX_ATTRIB_ARRAY13_NV, 0x865D) \
  CONST(GL_VERTEX_ATTRIB_ARRAY14_NV, 0x865E) \
  CONST(GL_VERTEX_ATTRIB_ARRAY15_NV, 0x865F) \
  CONST(GL_MAP1_VERTEX_ATTRIB0_4_NV, 0x8660) \
  CONST(GL_MAP1_VERTEX_ATTRIB1_4_NV, 0x8661) \
  CONST(GL_MAP1_VERTEX_ATTRIB2_4_NV, 0x8662) \
  CONST(GL_MAP1_VERTEX_ATTRIB3_4_NV, 0x8663) \
  CONST(GL_MAP1_VERTEX_ATTRIB4_4_NV, 0x8664) \
  CONST(GL_MAP1_VERTEX_ATTRIB5_4_NV, 0x8665) \
  CONST(GL_MAP1_VERTEX_ATTRIB6_4_NV, 0x8666) \
  CONST(GL_MAP1_VERTEX_ATTRIB7_4_NV, 0x8667) \
  CONST(GL_MAP1_VERTEX_ATTRIB8_4_NV, 0x8668) \
  CONST(GL_MAP1_VERTEX_ATTRIB9_4_NV, 0x8669) \
  CONST(GL_MAP1_VERTEX_ATTRIB10_4_NV, 0x866A) \
  CONST(GL_MAP1_VERTEX_ATTRIB11_4_NV, 0x866B) \
  CONST(GL_MAP1_VERTEX_ATTRIB12_4_NV, 0x866C) \
  CONST(GL_MAP1_VERTEX_ATTRIB13_4_NV, 0x866D) \
  CONST(GL_MAP1_VERTEX_ATTRIB14_4_NV, 0x866E) \
  CONST(GL_MAP1_VERTEX_ATTRIB15_4_NV, 0x866F) \
  CONST(GL_MAP2_VERTEX_ATTRIB0_4_NV, 0x8670) \
  CONST(GL_MAP2_VERTEX_ATTRIB1_4_NV, 0x8671) \
  CONST(GL_MAP2_VERTEX_ATTRIB2_4_NV, 0x8672) \
  CONST(GL_MAP2_VERTEX_ATTRIB3_4_NV, 0x8673) \
  CONST(GL_MAP2_VERTEX_ATTRIB4_4_NV, 0x8674) \
  CONST(GL_MAP2_VERTEX_ATTRIB5_4_NV, 0x8675) \
  CONST(GL_MAP2_VERTEX_ATTRIB6_4_NV, 0x8676) \
  CONST(GL_MAP2_VERTEX_ATTRIB7_4_NV, 0x8677) \
  CONST(GL_MAP2_VERTEX_ATTRIB8_4_NV, 0x8678) \
  CONST(GL_MAP2_VERTEX_ATTRIB9_4_NV, 0x8679) \
  CONST(GL_MAP2_VERTEX_ATTRIB10_4_NV, 0x867A) \
  CONST(GL_MAP2_VERTEX_ATTRIB11_4_NV, 0x867B) \
  CONST(GL_MAP2_VERTEX_ATTRIB12_4_NV, 0x867C) \
  CONST(GL_MAP2_VERTEX_ATTRIB13_4_NV, 0x867D) \
  CONST(GL_MAP2_VERTEX_ATTRIB14_4_NV, 0x867E) \
  CONST(GL_MAP2_VERTEX_ATTRIB15_4_NV, 0x867F) \
  END()
#else
#define EXTENSION_GL_NV_vertex_program(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_texture_coordinate_clamp
#define GL_SGIX_texture_coordinate_clamp 1
#define EXTENSION_GL_SGIX_texture_coordinate_clamp(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_texture_coordinate_clamp) \
  CONST(GL_TEXTURE_MAX_CLAMP_S_SGIX, 0x8369) \
  CONST(GL_TEXTURE_MAX_CLAMP_T_SGIX, 0x836A) \
  CONST(GL_TEXTURE_MAX_CLAMP_R_SGIX, 0x836B) \
  END()
#else
#define EXTENSION_GL_SGIX_texture_coordinate_clamp(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_scalebias_hint
#define GL_SGIX_scalebias_hint 1
#define EXTENSION_GL_SGIX_scalebias_hint(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_scalebias_hint) \
  CONST(GL_SCALEBIAS_HINT_SGIX, 0x8322) \
  END()
#else
#define EXTENSION_GL_SGIX_scalebias_hint(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_OML_interlace
#define GL_OML_interlace 1
#define EXTENSION_GL_OML_interlace(NAME, FUNC, CONST, END) \
  NAME(GL_OML_interlace) \
  CONST(GL_INTERLACE_OML, 0x8980) \
  CONST(GL_INTERLACE_READ_OML, 0x8981) \
  END()
#else
#define EXTENSION_GL_OML_interlace(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_OML_subsample
#define GL_OML_subsample 1
#define EXTENSION_GL_OML_subsample(NAME, FUNC, CONST, END) \
  NAME(GL_OML_subsample) \
  CONST(GL_FORMAT_SUBSAMPLE_24_24_OML, 0x8982) \
  CONST(GL_FORMAT_SUBSAMPLE_244_244_OML, 0x8983) \
  END()
#else
#define EXTENSION_GL_OML_subsample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_OML_resample
#define GL_OML_resample 1
#define EXTENSION_GL_OML_resample(NAME, FUNC, CONST, END) \
  NAME(GL_OML_resample) \
  CONST(GL_PACK_RESAMPLE_OML, 0x8984) \
  CONST(GL_UNPACK_RESAMPLE_OML, 0x8985) \
  CONST(GL_RESAMPLE_REPLICATE_OML, 0x8986) \
  CONST(GL_RESAMPLE_ZERO_FILL_OML, 0x8987) \
  CONST(GL_RESAMPLE_AVERAGE_OML, 0x8988) \
  CONST(GL_RESAMPLE_DECIMATE_OML, 0x8989) \
  END()
#else
#define EXTENSION_GL_OML_resample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_copy_depth_to_color
#define GL_NV_copy_depth_to_color 1
#define EXTENSION_GL_NV_copy_depth_to_color(NAME, FUNC, CONST, END) \
  NAME(GL_NV_copy_depth_to_color) \
  CONST(GL_DEPTH_STENCIL_TO_RGBA_NV, 0x886E) \
  CONST(GL_DEPTH_STENCIL_TO_BGRA_NV, 0x886F) \
  END()
#else
#define EXTENSION_GL_NV_copy_depth_to_color(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_envmap_bumpmap
#define GL_ATI_envmap_bumpmap 1
#define EXTENSION_GL_ATI_envmap_bumpmap(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_envmap_bumpmap) \
  FUNC(void, glTexBumpParameterivATI, GLTEXBUMPPARAMETERIVATI, (GLenum pname, const GLint * param)) \
  FUNC(void, glTexBumpParameterfvATI, GLTEXBUMPPARAMETERFVATI, (GLenum pname, const GLfloat * param)) \
  FUNC(void, glGetTexBumpParameterivATI, GLGETTEXBUMPPARAMETERIVATI, (GLenum pname, GLint * param)) \
  FUNC(void, glGetTexBumpParameterfvATI, GLGETTEXBUMPPARAMETERFVATI, (GLenum pname, GLfloat * param)) \
  CONST(GL_BUMP_ROT_MATRIX_ATI, 0x8775) \
  CONST(GL_BUMP_ROT_MATRIX_SIZE_ATI, 0x8776) \
  CONST(GL_BUMP_NUM_TEX_UNITS_ATI, 0x8777) \
  CONST(GL_BUMP_TEX_UNITS_ATI, 0x8778) \
  CONST(GL_DUDV_ATI, 0x8779) \
  CONST(GL_DU8DV8_ATI, 0x877A) \
  CONST(GL_BUMP_ENVMAP_ATI, 0x877B) \
  CONST(GL_BUMP_TARGET_ATI, 0x877C) \
  END()
#else
#define EXTENSION_GL_ATI_envmap_bumpmap(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_fragment_shader
#define GL_ATI_fragment_shader 1
#define EXTENSION_GL_ATI_fragment_shader(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_fragment_shader) \
  FUNC(GLuint, glGenFragmentShadersATI, GLGENFRAGMENTSHADERSATI, (GLuint range)) \
  FUNC(void, glBindFragmentShaderATI, GLBINDFRAGMENTSHADERATI, (GLuint id)) \
  FUNC(void, glDeleteFragmentShaderATI, GLDELETEFRAGMENTSHADERATI, (GLuint id)) \
  FUNC(void, glBeginFragmentShaderATI, GLBEGINFRAGMENTSHADERATI, ()) \
  FUNC(void, glEndFragmentShaderATI, GLENDFRAGMENTSHADERATI, ()) \
  FUNC(void, glPassTexCoordATI, GLPASSTEXCOORDATI, (GLuint dst, GLuint coord, GLenum swizzle)) \
  FUNC(void, glSampleMapATI, GLSAMPLEMAPATI, (GLuint dst, GLuint interp, GLenum swizzle)) \
  FUNC(void, glColorFragmentOp1ATI, GLCOLORFRAGMENTOP1ATI, (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)) \
  FUNC(void, glColorFragmentOp2ATI, GLCOLORFRAGMENTOP2ATI, (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)) \
  FUNC(void, glColorFragmentOp3ATI, GLCOLORFRAGMENTOP3ATI, (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)) \
  FUNC(void, glAlphaFragmentOp1ATI, GLALPHAFRAGMENTOP1ATI, (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)) \
  FUNC(void, glAlphaFragmentOp2ATI, GLALPHAFRAGMENTOP2ATI, (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)) \
  FUNC(void, glAlphaFragmentOp3ATI, GLALPHAFRAGMENTOP3ATI, (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)) \
  FUNC(void, glSetFragmentShaderConstantATI, GLSETFRAGMENTSHADERCONSTANTATI, (GLuint dst, const GLfloat * value)) \
  CONST(GL_FRAGMENT_SHADER_ATI, 0x8920) \
  CONST(GL_REG_0_ATI, 0x8921) \
  CONST(GL_REG_1_ATI, 0x8922) \
  CONST(GL_REG_2_ATI, 0x8923) \
  CONST(GL_REG_3_ATI, 0x8924) \
  CONST(GL_REG_4_ATI, 0x8925) \
  CONST(GL_REG_5_ATI, 0x8926) \
  CONST(GL_REG_6_ATI, 0x8927) \
  CONST(GL_REG_7_ATI, 0x8928) \
  CONST(GL_REG_8_ATI, 0x8929) \
  CONST(GL_REG_9_ATI, 0x892A) \
  CONST(GL_REG_10_ATI, 0x892B) \
  CONST(GL_REG_11_ATI, 0x892C) \
  CONST(GL_REG_12_ATI, 0x892D) \
  CONST(GL_REG_13_ATI, 0x892E) \
  CONST(GL_REG_14_ATI, 0x892F) \
  CONST(GL_REG_15_ATI, 0x8930) \
  CONST(GL_REG_16_ATI, 0x8931) \
  CONST(GL_REG_17_ATI, 0x8932) \
  CONST(GL_REG_18_ATI, 0x8933) \
  CONST(GL_REG_19_ATI, 0x8934) \
  CONST(GL_REG_20_ATI, 0x8935) \
  CONST(GL_REG_21_ATI, 0x8936) \
  CONST(GL_REG_22_ATI, 0x8937) \
  CONST(GL_REG_23_ATI, 0x8938) \
  CONST(GL_REG_24_ATI, 0x8939) \
  CONST(GL_REG_25_ATI, 0x893A) \
  CONST(GL_REG_26_ATI, 0x893B) \
  CONST(GL_REG_27_ATI, 0x893C) \
  CONST(GL_REG_28_ATI, 0x893D) \
  CONST(GL_REG_29_ATI, 0x893E) \
  CONST(GL_REG_30_ATI, 0x893F) \
  CONST(GL_REG_31_ATI, 0x8940) \
  CONST(GL_CON_0_ATI, 0x8941) \
  CONST(GL_CON_1_ATI, 0x8942) \
  CONST(GL_CON_2_ATI, 0x8943) \
  CONST(GL_CON_3_ATI, 0x8944) \
  CONST(GL_CON_4_ATI, 0x8945) \
  CONST(GL_CON_5_ATI, 0x8946) \
  CONST(GL_CON_6_ATI, 0x8947) \
  CONST(GL_CON_7_ATI, 0x8948) \
  CONST(GL_CON_8_ATI, 0x8949) \
  CONST(GL_CON_9_ATI, 0x894A) \
  CONST(GL_CON_10_ATI, 0x894B) \
  CONST(GL_CON_11_ATI, 0x894C) \
  CONST(GL_CON_12_ATI, 0x894D) \
  CONST(GL_CON_13_ATI, 0x894E) \
  CONST(GL_CON_14_ATI, 0x894F) \
  CONST(GL_CON_15_ATI, 0x8950) \
  CONST(GL_CON_16_ATI, 0x8951) \
  CONST(GL_CON_17_ATI, 0x8952) \
  CONST(GL_CON_18_ATI, 0x8953) \
  CONST(GL_CON_19_ATI, 0x8954) \
  CONST(GL_CON_20_ATI, 0x8955) \
  CONST(GL_CON_21_ATI, 0x8956) \
  CONST(GL_CON_22_ATI, 0x8957) \
  CONST(GL_CON_23_ATI, 0x8958) \
  CONST(GL_CON_24_ATI, 0x8959) \
  CONST(GL_CON_25_ATI, 0x895A) \
  CONST(GL_CON_26_ATI, 0x895B) \
  CONST(GL_CON_27_ATI, 0x895C) \
  CONST(GL_CON_28_ATI, 0x895D) \
  CONST(GL_CON_29_ATI, 0x895E) \
  CONST(GL_CON_30_ATI, 0x895F) \
  CONST(GL_CON_31_ATI, 0x8960) \
  CONST(GL_MOV_ATI, 0x8961) \
  CONST(GL_ADD_ATI, 0x8963) \
  CONST(GL_MUL_ATI, 0x8964) \
  CONST(GL_SUB_ATI, 0x8965) \
  CONST(GL_DOT3_ATI, 0x8966) \
  CONST(GL_DOT4_ATI, 0x8967) \
  CONST(GL_MAD_ATI, 0x8968) \
  CONST(GL_LERP_ATI, 0x8969) \
  CONST(GL_CND_ATI, 0x896A) \
  CONST(GL_CND0_ATI, 0x896B) \
  CONST(GL_DOT2_ADD_ATI, 0x896C) \
  CONST(GL_SECONDARY_INTERPOLATOR_ATI, 0x896D) \
  CONST(GL_NUM_FRAGMENT_REGISTERS_ATI, 0x896E) \
  CONST(GL_NUM_FRAGMENT_CONSTANTS_ATI, 0x896F) \
  CONST(GL_NUM_PASSES_ATI, 0x8970) \
  CONST(GL_NUM_INSTRUCTIONS_PER_PASS_ATI, 0x8971) \
  CONST(GL_NUM_INSTRUCTIONS_TOTAL_ATI, 0x8972) \
  CONST(GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI, 0x8973) \
  CONST(GL_NUM_LOOPBACK_COMPONENTS_ATI, 0x8974) \
  CONST(GL_COLOR_ALPHA_PAIRING_ATI, 0x8975) \
  CONST(GL_SWIZZLE_STR_ATI, 0x8976) \
  CONST(GL_SWIZZLE_STQ_ATI, 0x8977) \
  CONST(GL_SWIZZLE_STR_DR_ATI, 0x8978) \
  CONST(GL_SWIZZLE_STQ_DQ_ATI, 0x8979) \
  CONST(GL_SWIZZLE_STRQ_ATI, 0x897A) \
  CONST(GL_SWIZZLE_STRQ_DQ_ATI, 0x897B) \
  CONST(GL_RED_BIT_ATI, 0x00000001) \
  CONST(GL_GREEN_BIT_ATI, 0x00000002) \
  CONST(GL_BLUE_BIT_ATI, 0x00000004) \
  CONST(GL_2X_BIT_ATI, 0x00000001) \
  CONST(GL_4X_BIT_ATI, 0x00000002) \
  CONST(GL_8X_BIT_ATI, 0x00000004) \
  CONST(GL_HALF_BIT_ATI, 0x00000008) \
  CONST(GL_QUARTER_BIT_ATI, 0x00000010) \
  CONST(GL_EIGHTH_BIT_ATI, 0x00000020) \
  CONST(GL_SATURATE_BIT_ATI, 0x00000040) \
  CONST(GL_COMP_BIT_ATI, 0x00000002) \
  CONST(GL_NEGATE_BIT_ATI, 0x00000004) \
  CONST(GL_BIAS_BIT_ATI, 0x00000008) \
  END()
#else
#define EXTENSION_GL_ATI_fragment_shader(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_pn_triangles
#define GL_ATI_pn_triangles 1
#define EXTENSION_GL_ATI_pn_triangles(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_pn_triangles) \
  FUNC(void, glPNTrianglesiATI, GLPNTRIANGLESIATI, (GLenum pname, GLint param)) \
  FUNC(void, glPNTrianglesfATI, GLPNTRIANGLESFATI, (GLenum pname, GLfloat param)) \
  CONST(GL_PN_TRIANGLES_ATI, 0x87F0) \
  CONST(GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI, 0x87F1) \
  CONST(GL_PN_TRIANGLES_POINT_MODE_ATI, 0x87F2) \
  CONST(GL_PN_TRIANGLES_NORMAL_MODE_ATI, 0x87F3) \
  CONST(GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI, 0x87F4) \
  CONST(GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI, 0x87F5) \
  CONST(GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI, 0x87F6) \
  CONST(GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI, 0x87F7) \
  CONST(GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI, 0x87F8) \
  END()
#else
#define EXTENSION_GL_ATI_pn_triangles(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_vertex_array_object
#define GL_ATI_vertex_array_object 1
#define EXTENSION_GL_ATI_vertex_array_object(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_vertex_array_object) \
  FUNC(GLuint, glNewObjectBufferATI, GLNEWOBJECTBUFFERATI, (GLsizei size, const GLvoid * pointer, GLenum usage)) \
  FUNC(GLboolean, glIsObjectBufferATI, GLISOBJECTBUFFERATI, (GLuint buffer)) \
  FUNC(void, glUpdateObjectBufferATI, GLUPDATEOBJECTBUFFERATI, (GLuint buffer, GLuint offset, GLsizei size, const GLvoid * pointer, GLenum preserve)) \
  FUNC(void, glGetObjectBufferfvATI, GLGETOBJECTBUFFERFVATI, (GLuint buffer, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetObjectBufferivATI, GLGETOBJECTBUFFERIVATI, (GLuint buffer, GLenum pname, GLint * params)) \
  FUNC(void, glFreeObjectBufferATI, GLFREEOBJECTBUFFERATI, (GLuint buffer)) \
  FUNC(void, glArrayObjectATI, GLARRAYOBJECTATI, (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)) \
  FUNC(void, glGetArrayObjectfvATI, GLGETARRAYOBJECTFVATI, (GLenum array, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetArrayObjectivATI, GLGETARRAYOBJECTIVATI, (GLenum array, GLenum pname, GLint * params)) \
  FUNC(void, glVariantArrayObjectATI, GLVARIANTARRAYOBJECTATI, (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)) \
  FUNC(void, glGetVariantArrayObjectfvATI, GLGETVARIANTARRAYOBJECTFVATI, (GLuint id, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetVariantArrayObjectivATI, GLGETVARIANTARRAYOBJECTIVATI, (GLuint id, GLenum pname, GLint * params)) \
  CONST(GL_STATIC_ATI, 0x8760) \
  CONST(GL_DYNAMIC_ATI, 0x8761) \
  CONST(GL_PRESERVE_ATI, 0x8762) \
  CONST(GL_DISCARD_ATI, 0x8763) \
  CONST(GL_OBJECT_BUFFER_SIZE_ATI, 0x8764) \
  CONST(GL_OBJECT_BUFFER_USAGE_ATI, 0x8765) \
  CONST(GL_ARRAY_OBJECT_BUFFER_ATI, 0x8766) \
  CONST(GL_ARRAY_OBJECT_OFFSET_ATI, 0x8767) \
  END()
#else
#define EXTENSION_GL_ATI_vertex_array_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_vertex_shader
#define GL_EXT_vertex_shader 1
#define EXTENSION_GL_EXT_vertex_shader(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_vertex_shader) \
  FUNC(void, glBeginVertexShaderEXT, GLBEGINVERTEXSHADEREXT, ()) \
  FUNC(void, glEndVertexShaderEXT, GLENDVERTEXSHADEREXT, ()) \
  FUNC(void, glBindVertexShaderEXT, GLBINDVERTEXSHADEREXT, (GLuint id)) \
  FUNC(GLuint, glGenVertexShadersEXT, GLGENVERTEXSHADERSEXT, (GLuint range)) \
  FUNC(void, glDeleteVertexShaderEXT, GLDELETEVERTEXSHADEREXT, (GLuint id)) \
  FUNC(void, glShaderOp1EXT, GLSHADEROP1EXT, (GLenum op, GLuint res, GLuint arg1)) \
  FUNC(void, glShaderOp2EXT, GLSHADEROP2EXT, (GLenum op, GLuint res, GLuint arg1, GLuint arg2)) \
  FUNC(void, glShaderOp3EXT, GLSHADEROP3EXT, (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)) \
  FUNC(void, glSwizzleEXT, GLSWIZZLEEXT, (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)) \
  FUNC(void, glWriteMaskEXT, GLWRITEMASKEXT, (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)) \
  FUNC(void, glInsertComponentEXT, GLINSERTCOMPONENTEXT, (GLuint res, GLuint src, GLuint num)) \
  FUNC(void, glExtractComponentEXT, GLEXTRACTCOMPONENTEXT, (GLuint res, GLuint src, GLuint num)) \
  FUNC(GLuint, glGenSymbolsEXT, GLGENSYMBOLSEXT, (GLenum datatype, GLenum storagetype, GLenum range, GLuint components)) \
  FUNC(void, glSetInvariantEXT, GLSETINVARIANTEXT, (GLuint id, GLenum type, const GLvoid * addr)) \
  FUNC(void, glSetLocalConstantEXT, GLSETLOCALCONSTANTEXT, (GLuint id, GLenum type, const GLvoid * addr)) \
  FUNC(void, glVariantbvEXT, GLVARIANTBVEXT, (GLuint id, const GLbyte * addr)) \
  FUNC(void, glVariantsvEXT, GLVARIANTSVEXT, (GLuint id, const GLshort * addr)) \
  FUNC(void, glVariantivEXT, GLVARIANTIVEXT, (GLuint id, const GLint * addr)) \
  FUNC(void, glVariantfvEXT, GLVARIANTFVEXT, (GLuint id, const GLfloat * addr)) \
  FUNC(void, glVariantdvEXT, GLVARIANTDVEXT, (GLuint id, const GLdouble * addr)) \
  FUNC(void, glVariantubvEXT, GLVARIANTUBVEXT, (GLuint id, const GLubyte * addr)) \
  FUNC(void, glVariantusvEXT, GLVARIANTUSVEXT, (GLuint id, const GLushort * addr)) \
  FUNC(void, glVariantuivEXT, GLVARIANTUIVEXT, (GLuint id, const GLuint * addr)) \
  FUNC(void, glVariantPointerEXT, GLVARIANTPOINTEREXT, (GLuint id, GLenum type, GLuint stride, const GLvoid * addr)) \
  FUNC(void, glEnableVariantClientStateEXT, GLENABLEVARIANTCLIENTSTATEEXT, (GLuint id)) \
  FUNC(void, glDisableVariantClientStateEXT, GLDISABLEVARIANTCLIENTSTATEEXT, (GLuint id)) \
  FUNC(GLuint, glBindLightParameterEXT, GLBINDLIGHTPARAMETEREXT, (GLenum light, GLenum value)) \
  FUNC(GLuint, glBindMaterialParameterEXT, GLBINDMATERIALPARAMETEREXT, (GLenum face, GLenum value)) \
  FUNC(GLuint, glBindTexGenParameterEXT, GLBINDTEXGENPARAMETEREXT, (GLenum unit, GLenum coord, GLenum value)) \
  FUNC(GLuint, glBindTextureUnitParameterEXT, GLBINDTEXTUREUNITPARAMETEREXT, (GLenum unit, GLenum value)) \
  FUNC(GLuint, glBindParameterEXT, GLBINDPARAMETEREXT, (GLenum value)) \
  FUNC(GLboolean, glIsVariantEnabledEXT, GLISVARIANTENABLEDEXT, (GLuint id, GLenum cap)) \
  FUNC(void, glGetVariantBooleanvEXT, GLGETVARIANTBOOLEANVEXT, (GLuint id, GLenum value, GLboolean * data)) \
  FUNC(void, glGetVariantIntegervEXT, GLGETVARIANTINTEGERVEXT, (GLuint id, GLenum value, GLint * data)) \
  FUNC(void, glGetVariantFloatvEXT, GLGETVARIANTFLOATVEXT, (GLuint id, GLenum value, GLfloat * data)) \
  FUNC(void, glGetVariantPointervEXT, GLGETVARIANTPOINTERVEXT, (GLuint id, GLenum value, GLvoid* * data)) \
  FUNC(void, glGetInvariantBooleanvEXT, GLGETINVARIANTBOOLEANVEXT, (GLuint id, GLenum value, GLboolean * data)) \
  FUNC(void, glGetInvariantIntegervEXT, GLGETINVARIANTINTEGERVEXT, (GLuint id, GLenum value, GLint * data)) \
  FUNC(void, glGetInvariantFloatvEXT, GLGETINVARIANTFLOATVEXT, (GLuint id, GLenum value, GLfloat * data)) \
  FUNC(void, glGetLocalConstantBooleanvEXT, GLGETLOCALCONSTANTBOOLEANVEXT, (GLuint id, GLenum value, GLboolean * data)) \
  FUNC(void, glGetLocalConstantIntegervEXT, GLGETLOCALCONSTANTINTEGERVEXT, (GLuint id, GLenum value, GLint * data)) \
  FUNC(void, glGetLocalConstantFloatvEXT, GLGETLOCALCONSTANTFLOATVEXT, (GLuint id, GLenum value, GLfloat * data)) \
  CONST(GL_VERTEX_SHADER_EXT, 0x8780) \
  CONST(GL_VERTEX_SHADER_BINDING_EXT, 0x8781) \
  CONST(GL_OP_INDEX_EXT, 0x8782) \
  CONST(GL_OP_NEGATE_EXT, 0x8783) \
  CONST(GL_OP_DOT3_EXT, 0x8784) \
  CONST(GL_OP_DOT4_EXT, 0x8785) \
  CONST(GL_OP_MUL_EXT, 0x8786) \
  CONST(GL_OP_ADD_EXT, 0x8787) \
  CONST(GL_OP_MADD_EXT, 0x8788) \
  CONST(GL_OP_FRAC_EXT, 0x8789) \
  CONST(GL_OP_MAX_EXT, 0x878A) \
  CONST(GL_OP_MIN_EXT, 0x878B) \
  CONST(GL_OP_SET_GE_EXT, 0x878C) \
  CONST(GL_OP_SET_LT_EXT, 0x878D) \
  CONST(GL_OP_CLAMP_EXT, 0x878E) \
  CONST(GL_OP_FLOOR_EXT, 0x878F) \
  CONST(GL_OP_ROUND_EXT, 0x8790) \
  CONST(GL_OP_EXP_BASE_2_EXT, 0x8791) \
  CONST(GL_OP_LOG_BASE_2_EXT, 0x8792) \
  CONST(GL_OP_POWER_EXT, 0x8793) \
  CONST(GL_OP_RECIP_EXT, 0x8794) \
  CONST(GL_OP_RECIP_SQRT_EXT, 0x8795) \
  CONST(GL_OP_SUB_EXT, 0x8796) \
  CONST(GL_OP_CROSS_PRODUCT_EXT, 0x8797) \
  CONST(GL_OP_MULTIPLY_MATRIX_EXT, 0x8798) \
  CONST(GL_OP_MOV_EXT, 0x8799) \
  CONST(GL_OUTPUT_VERTEX_EXT, 0x879A) \
  CONST(GL_OUTPUT_COLOR0_EXT, 0x879B) \
  CONST(GL_OUTPUT_COLOR1_EXT, 0x879C) \
  CONST(GL_OUTPUT_TEXTURE_COORD0_EXT, 0x879D) \
  CONST(GL_OUTPUT_TEXTURE_COORD1_EXT, 0x879E) \
  CONST(GL_OUTPUT_TEXTURE_COORD2_EXT, 0x879F) \
  CONST(GL_OUTPUT_TEXTURE_COORD3_EXT, 0x87A0) \
  CONST(GL_OUTPUT_TEXTURE_COORD4_EXT, 0x87A1) \
  CONST(GL_OUTPUT_TEXTURE_COORD5_EXT, 0x87A2) \
  CONST(GL_OUTPUT_TEXTURE_COORD6_EXT, 0x87A3) \
  CONST(GL_OUTPUT_TEXTURE_COORD7_EXT, 0x87A4) \
  CONST(GL_OUTPUT_TEXTURE_COORD8_EXT, 0x87A5) \
  CONST(GL_OUTPUT_TEXTURE_COORD9_EXT, 0x87A6) \
  CONST(GL_OUTPUT_TEXTURE_COORD10_EXT, 0x87A7) \
  CONST(GL_OUTPUT_TEXTURE_COORD11_EXT, 0x87A8) \
  CONST(GL_OUTPUT_TEXTURE_COORD12_EXT, 0x87A9) \
  CONST(GL_OUTPUT_TEXTURE_COORD13_EXT, 0x87AA) \
  CONST(GL_OUTPUT_TEXTURE_COORD14_EXT, 0x87AB) \
  CONST(GL_OUTPUT_TEXTURE_COORD15_EXT, 0x87AC) \
  CONST(GL_OUTPUT_TEXTURE_COORD16_EXT, 0x87AD) \
  CONST(GL_OUTPUT_TEXTURE_COORD17_EXT, 0x87AE) \
  CONST(GL_OUTPUT_TEXTURE_COORD18_EXT, 0x87AF) \
  CONST(GL_OUTPUT_TEXTURE_COORD19_EXT, 0x87B0) \
  CONST(GL_OUTPUT_TEXTURE_COORD20_EXT, 0x87B1) \
  CONST(GL_OUTPUT_TEXTURE_COORD21_EXT, 0x87B2) \
  CONST(GL_OUTPUT_TEXTURE_COORD22_EXT, 0x87B3) \
  CONST(GL_OUTPUT_TEXTURE_COORD23_EXT, 0x87B4) \
  CONST(GL_OUTPUT_TEXTURE_COORD24_EXT, 0x87B5) \
  CONST(GL_OUTPUT_TEXTURE_COORD25_EXT, 0x87B6) \
  CONST(GL_OUTPUT_TEXTURE_COORD26_EXT, 0x87B7) \
  CONST(GL_OUTPUT_TEXTURE_COORD27_EXT, 0x87B8) \
  CONST(GL_OUTPUT_TEXTURE_COORD28_EXT, 0x87B9) \
  CONST(GL_OUTPUT_TEXTURE_COORD29_EXT, 0x87BA) \
  CONST(GL_OUTPUT_TEXTURE_COORD30_EXT, 0x87BB) \
  CONST(GL_OUTPUT_TEXTURE_COORD31_EXT, 0x87BC) \
  CONST(GL_OUTPUT_FOG_EXT, 0x87BD) \
  CONST(GL_SCALAR_EXT, 0x87BE) \
  CONST(GL_VECTOR_EXT, 0x87BF) \
  CONST(GL_MATRIX_EXT, 0x87C0) \
  CONST(GL_VARIANT_EXT, 0x87C1) \
  CONST(GL_INVARIANT_EXT, 0x87C2) \
  CONST(GL_LOCAL_CONSTANT_EXT, 0x87C3) \
  CONST(GL_LOCAL_EXT, 0x87C4) \
  CONST(GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT, 0x87C5) \
  CONST(GL_MAX_VERTEX_SHADER_VARIANTS_EXT, 0x87C6) \
  CONST(GL_MAX_VERTEX_SHADER_INVARIANTS_EXT, 0x87C7) \
  CONST(GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT, 0x87C8) \
  CONST(GL_MAX_VERTEX_SHADER_LOCALS_EXT, 0x87C9) \
  CONST(GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT, 0x87CA) \
  CONST(GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT, 0x87CB) \
  CONST(GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT, 0x87CC) \
  CONST(GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT, 0x87CD) \
  CONST(GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT, 0x87CE) \
  CONST(GL_VERTEX_SHADER_INSTRUCTIONS_EXT, 0x87CF) \
  CONST(GL_VERTEX_SHADER_VARIANTS_EXT, 0x87D0) \
  CONST(GL_VERTEX_SHADER_INVARIANTS_EXT, 0x87D1) \
  CONST(GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT, 0x87D2) \
  CONST(GL_VERTEX_SHADER_LOCALS_EXT, 0x87D3) \
  CONST(GL_VERTEX_SHADER_OPTIMIZED_EXT, 0x87D4) \
  CONST(GL_X_EXT, 0x87D5) \
  CONST(GL_Y_EXT, 0x87D6) \
  CONST(GL_Z_EXT, 0x87D7) \
  CONST(GL_W_EXT, 0x87D8) \
  CONST(GL_NEGATIVE_X_EXT, 0x87D9) \
  CONST(GL_NEGATIVE_Y_EXT, 0x87DA) \
  CONST(GL_NEGATIVE_Z_EXT, 0x87DB) \
  CONST(GL_NEGATIVE_W_EXT, 0x87DC) \
  CONST(GL_ZERO_EXT, 0x87DD) \
  CONST(GL_ONE_EXT, 0x87DE) \
  CONST(GL_NEGATIVE_ONE_EXT, 0x87DF) \
  CONST(GL_NORMALIZED_RANGE_EXT, 0x87E0) \
  CONST(GL_FULL_RANGE_EXT, 0x87E1) \
  CONST(GL_CURRENT_VERTEX_EXT, 0x87E2) \
  CONST(GL_MVP_MATRIX_EXT, 0x87E3) \
  CONST(GL_VARIANT_VALUE_EXT, 0x87E4) \
  CONST(GL_VARIANT_DATATYPE_EXT, 0x87E5) \
  CONST(GL_VARIANT_ARRAY_STRIDE_EXT, 0x87E6) \
  CONST(GL_VARIANT_ARRAY_TYPE_EXT, 0x87E7) \
  CONST(GL_VARIANT_ARRAY_EXT, 0x87E8) \
  CONST(GL_VARIANT_ARRAY_POINTER_EXT, 0x87E9) \
  CONST(GL_INVARIANT_VALUE_EXT, 0x87EA) \
  CONST(GL_INVARIANT_DATATYPE_EXT, 0x87EB) \
  CONST(GL_LOCAL_CONSTANT_VALUE_EXT, 0x87EC) \
  CONST(GL_LOCAL_CONSTANT_DATATYPE_EXT, 0x87ED) \
  END()
#else
#define EXTENSION_GL_EXT_vertex_shader(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_vertex_streams
#define GL_ATI_vertex_streams 1
#define EXTENSION_GL_ATI_vertex_streams(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_vertex_streams) \
  FUNC(void, glVertexStream1sATI, GLVERTEXSTREAM1SATI, (GLenum stream, GLshort x)) \
  FUNC(void, glVertexStream1svATI, GLVERTEXSTREAM1SVATI, (GLenum stream, const GLshort * coords)) \
  FUNC(void, glVertexStream1iATI, GLVERTEXSTREAM1IATI, (GLenum stream, GLint x)) \
  FUNC(void, glVertexStream1ivATI, GLVERTEXSTREAM1IVATI, (GLenum stream, const GLint * coords)) \
  FUNC(void, glVertexStream1fATI, GLVERTEXSTREAM1FATI, (GLenum stream, GLfloat x)) \
  FUNC(void, glVertexStream1fvATI, GLVERTEXSTREAM1FVATI, (GLenum stream, const GLfloat * coords)) \
  FUNC(void, glVertexStream1dATI, GLVERTEXSTREAM1DATI, (GLenum stream, GLdouble x)) \
  FUNC(void, glVertexStream1dvATI, GLVERTEXSTREAM1DVATI, (GLenum stream, const GLdouble * coords)) \
  FUNC(void, glVertexStream2sATI, GLVERTEXSTREAM2SATI, (GLenum stream, GLshort x, GLshort y)) \
  FUNC(void, glVertexStream2svATI, GLVERTEXSTREAM2SVATI, (GLenum stream, const GLshort * coords)) \
  FUNC(void, glVertexStream2iATI, GLVERTEXSTREAM2IATI, (GLenum stream, GLint x, GLint y)) \
  FUNC(void, glVertexStream2ivATI, GLVERTEXSTREAM2IVATI, (GLenum stream, const GLint * coords)) \
  FUNC(void, glVertexStream2fATI, GLVERTEXSTREAM2FATI, (GLenum stream, GLfloat x, GLfloat y)) \
  FUNC(void, glVertexStream2fvATI, GLVERTEXSTREAM2FVATI, (GLenum stream, const GLfloat * coords)) \
  FUNC(void, glVertexStream2dATI, GLVERTEXSTREAM2DATI, (GLenum stream, GLdouble x, GLdouble y)) \
  FUNC(void, glVertexStream2dvATI, GLVERTEXSTREAM2DVATI, (GLenum stream, const GLdouble * coords)) \
  FUNC(void, glVertexStream3sATI, GLVERTEXSTREAM3SATI, (GLenum stream, GLshort x, GLshort y, GLshort z)) \
  FUNC(void, glVertexStream3svATI, GLVERTEXSTREAM3SVATI, (GLenum stream, const GLshort * coords)) \
  FUNC(void, glVertexStream3iATI, GLVERTEXSTREAM3IATI, (GLenum stream, GLint x, GLint y, GLint z)) \
  FUNC(void, glVertexStream3ivATI, GLVERTEXSTREAM3IVATI, (GLenum stream, const GLint * coords)) \
  FUNC(void, glVertexStream3fATI, GLVERTEXSTREAM3FATI, (GLenum stream, GLfloat x, GLfloat y, GLfloat z)) \
  FUNC(void, glVertexStream3fvATI, GLVERTEXSTREAM3FVATI, (GLenum stream, const GLfloat * coords)) \
  FUNC(void, glVertexStream3dATI, GLVERTEXSTREAM3DATI, (GLenum stream, GLdouble x, GLdouble y, GLdouble z)) \
  FUNC(void, glVertexStream3dvATI, GLVERTEXSTREAM3DVATI, (GLenum stream, const GLdouble * coords)) \
  FUNC(void, glVertexStream4sATI, GLVERTEXSTREAM4SATI, (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w)) \
  FUNC(void, glVertexStream4svATI, GLVERTEXSTREAM4SVATI, (GLenum stream, const GLshort * coords)) \
  FUNC(void, glVertexStream4iATI, GLVERTEXSTREAM4IATI, (GLenum stream, GLint x, GLint y, GLint z, GLint w)) \
  FUNC(void, glVertexStream4ivATI, GLVERTEXSTREAM4IVATI, (GLenum stream, const GLint * coords)) \
  FUNC(void, glVertexStream4fATI, GLVERTEXSTREAM4FATI, (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glVertexStream4fvATI, GLVERTEXSTREAM4FVATI, (GLenum stream, const GLfloat * coords)) \
  FUNC(void, glVertexStream4dATI, GLVERTEXSTREAM4DATI, (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glVertexStream4dvATI, GLVERTEXSTREAM4DVATI, (GLenum stream, const GLdouble * coords)) \
  FUNC(void, glNormalStream3bATI, GLNORMALSTREAM3BATI, (GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz)) \
  FUNC(void, glNormalStream3bvATI, GLNORMALSTREAM3BVATI, (GLenum stream, const GLbyte * coords)) \
  FUNC(void, glNormalStream3sATI, GLNORMALSTREAM3SATI, (GLenum stream, GLshort nx, GLshort ny, GLshort nz)) \
  FUNC(void, glNormalStream3svATI, GLNORMALSTREAM3SVATI, (GLenum stream, const GLshort * coords)) \
  FUNC(void, glNormalStream3iATI, GLNORMALSTREAM3IATI, (GLenum stream, GLint nx, GLint ny, GLint nz)) \
  FUNC(void, glNormalStream3ivATI, GLNORMALSTREAM3IVATI, (GLenum stream, const GLint * coords)) \
  FUNC(void, glNormalStream3fATI, GLNORMALSTREAM3FATI, (GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz)) \
  FUNC(void, glNormalStream3fvATI, GLNORMALSTREAM3FVATI, (GLenum stream, const GLfloat * coords)) \
  FUNC(void, glNormalStream3dATI, GLNORMALSTREAM3DATI, (GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz)) \
  FUNC(void, glNormalStream3dvATI, GLNORMALSTREAM3DVATI, (GLenum stream, const GLdouble * coords)) \
  FUNC(void, glClientActiveVertexStreamATI, GLCLIENTACTIVEVERTEXSTREAMATI, (GLenum stream)) \
  FUNC(void, glVertexBlendEnviATI, GLVERTEXBLENDENVIATI, (GLenum pname, GLint param)) \
  FUNC(void, glVertexBlendEnvfATI, GLVERTEXBLENDENVFATI, (GLenum pname, GLfloat param)) \
  CONST(GL_MAX_VERTEX_STREAMS_ATI, 0x876B) \
  CONST(GL_VERTEX_STREAM0_ATI, 0x876C) \
  CONST(GL_VERTEX_STREAM1_ATI, 0x876D) \
  CONST(GL_VERTEX_STREAM2_ATI, 0x876E) \
  CONST(GL_VERTEX_STREAM3_ATI, 0x876F) \
  CONST(GL_VERTEX_STREAM4_ATI, 0x8770) \
  CONST(GL_VERTEX_STREAM5_ATI, 0x8771) \
  CONST(GL_VERTEX_STREAM6_ATI, 0x8772) \
  CONST(GL_VERTEX_STREAM7_ATI, 0x8773) \
  CONST(GL_VERTEX_SOURCE_ATI, 0x8774) \
  END()
#else
#define EXTENSION_GL_ATI_vertex_streams(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_element_array
#define GL_ATI_element_array 1
#define EXTENSION_GL_ATI_element_array(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_element_array) \
  FUNC(void, glElementPointerATI, GLELEMENTPOINTERATI, (GLenum type, const GLvoid * pointer)) \
  FUNC(void, glDrawElementArrayATI, GLDRAWELEMENTARRAYATI, (GLenum mode, GLsizei count)) \
  FUNC(void, glDrawRangeElementArrayATI, GLDRAWRANGEELEMENTARRAYATI, (GLenum mode, GLuint start, GLuint end, GLsizei count)) \
  CONST(GL_ELEMENT_ARRAY_ATI, 0x8768) \
  CONST(GL_ELEMENT_ARRAY_TYPE_ATI, 0x8769) \
  CONST(GL_ELEMENT_ARRAY_POINTER_ATI, 0x876A) \
  END()
#else
#define EXTENSION_GL_ATI_element_array(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SUN_mesh_array
#define GL_SUN_mesh_array 1
#define EXTENSION_GL_SUN_mesh_array(NAME, FUNC, CONST, END) \
  NAME(GL_SUN_mesh_array) \
  FUNC(void, glDrawMeshArraysSUN, GLDRAWMESHARRAYSSUN, (GLenum mode, GLint first, GLsizei count, GLsizei width)) \
  CONST(GL_QUAD_MESH_SUN, 0x8614) \
  CONST(GL_TRIANGLE_MESH_SUN, 0x8615) \
  END()
#else
#define EXTENSION_GL_SUN_mesh_array(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SUN_slice_accum
#define GL_SUN_slice_accum 1
#define EXTENSION_GL_SUN_slice_accum(NAME, FUNC, CONST, END) \
  NAME(GL_SUN_slice_accum) \
  CONST(GL_SLICE_ACCUM_SUN, 0x85CC) \
  END()
#else
#define EXTENSION_GL_SUN_slice_accum(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_multisample_filter_hint
#define GL_NV_multisample_filter_hint 1
#define EXTENSION_GL_NV_multisample_filter_hint(NAME, FUNC, CONST, END) \
  NAME(GL_NV_multisample_filter_hint) \
  CONST(GL_MULTISAMPLE_FILTER_HINT_NV, 0x8534) \
  END()
#else
#define EXTENSION_GL_NV_multisample_filter_hint(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_depth_clamp
#define GL_NV_depth_clamp 1
#define EXTENSION_GL_NV_depth_clamp(NAME, FUNC, CONST, END) \
  NAME(GL_NV_depth_clamp) \
  CONST(GL_DEPTH_CLAMP_NV, 0x864F) \
  END()
#else
#define EXTENSION_GL_NV_depth_clamp(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_occlusion_query
#define GL_NV_occlusion_query 1
#define EXTENSION_GL_NV_occlusion_query(NAME, FUNC, CONST, END) \
  NAME(GL_NV_occlusion_query) \
  FUNC(void, glGenOcclusionQueriesNV, GLGENOCCLUSIONQUERIESNV, (GLsizei n, GLuint * ids)) \
  FUNC(void, glDeleteOcclusionQueriesNV, GLDELETEOCCLUSIONQUERIESNV, (GLsizei n, const GLuint * ids)) \
  FUNC(GLboolean, glIsOcclusionQueryNV, GLISOCCLUSIONQUERYNV, (GLuint id)) \
  FUNC(void, glBeginOcclusionQueryNV, GLBEGINOCCLUSIONQUERYNV, (GLuint id)) \
  FUNC(void, glEndOcclusionQueryNV, GLENDOCCLUSIONQUERYNV, ()) \
  FUNC(void, glGetOcclusionQueryivNV, GLGETOCCLUSIONQUERYIVNV, (GLuint id, GLenum pname, GLint * params)) \
  FUNC(void, glGetOcclusionQueryuivNV, GLGETOCCLUSIONQUERYUIVNV, (GLuint id, GLenum pname, GLuint * params)) \
  CONST(GL_PIXEL_COUNTER_BITS_NV, 0x8864) \
  CONST(GL_CURRENT_OCCLUSION_QUERY_ID_NV, 0x8865) \
  CONST(GL_PIXEL_COUNT_NV, 0x8866) \
  CONST(GL_PIXEL_COUNT_AVAILABLE_NV, 0x8867) \
  END()
#else
#define EXTENSION_GL_NV_occlusion_query(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_point_sprite
#define GL_NV_point_sprite 1
#define EXTENSION_GL_NV_point_sprite(NAME, FUNC, CONST, END) \
  NAME(GL_NV_point_sprite) \
  FUNC(void, glPointParameteriNV, GLPOINTPARAMETERINV, (GLenum pname, GLint param)) \
  FUNC(void, glPointParameterivNV, GLPOINTPARAMETERIVNV, (GLenum pname, const GLint * params)) \
  CONST(GL_POINT_SPRITE_NV, 0x8861) \
  CONST(GL_COORD_REPLACE_NV, 0x8862) \
  CONST(GL_POINT_SPRITE_R_MODE_NV, 0x8863) \
  END()
#else
#define EXTENSION_GL_NV_point_sprite(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texture_shader3
#define GL_NV_texture_shader3 1
#define EXTENSION_GL_NV_texture_shader3(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texture_shader3) \
  CONST(GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV, 0x8850) \
  CONST(GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV, 0x8851) \
  CONST(GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV, 0x8852) \
  CONST(GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV, 0x8853) \
  CONST(GL_OFFSET_HILO_TEXTURE_2D_NV, 0x8854) \
  CONST(GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV, 0x8855) \
  CONST(GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV, 0x8856) \
  CONST(GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV, 0x8857) \
  CONST(GL_DEPENDENT_HILO_TEXTURE_2D_NV, 0x8858) \
  CONST(GL_DEPENDENT_RGB_TEXTURE_3D_NV, 0x8859) \
  CONST(GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV, 0x885A) \
  CONST(GL_DOT_PRODUCT_PASS_THROUGH_NV, 0x885B) \
  CONST(GL_DOT_PRODUCT_TEXTURE_1D_NV, 0x885C) \
  CONST(GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV, 0x885D) \
  CONST(GL_HILO8_NV, 0x885E) \
  CONST(GL_SIGNED_HILO8_NV, 0x885F) \
  CONST(GL_FORCE_BLUE_TO_ONE_NV, 0x8860) \
  END()
#else
#define EXTENSION_GL_NV_texture_shader3(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_vertex_program1_1
#define GL_NV_vertex_program1_1 1
#define EXTENSION_GL_NV_vertex_program1_1(NAME, FUNC, CONST, END) \
  NAME(GL_NV_vertex_program1_1) \
  END()
#else
#define EXTENSION_GL_NV_vertex_program1_1(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_shadow_funcs
#define GL_EXT_shadow_funcs 1
#define EXTENSION_GL_EXT_shadow_funcs(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_shadow_funcs) \
  END()
#else
#define EXTENSION_GL_EXT_shadow_funcs(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_stencil_two_side
#define GL_EXT_stencil_two_side 1
#define EXTENSION_GL_EXT_stencil_two_side(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_stencil_two_side) \
  FUNC(void, glActiveStencilFaceEXT, GLACTIVESTENCILFACEEXT, (GLenum face)) \
  CONST(GL_STENCIL_TEST_TWO_SIDE_EXT, 0x8910) \
  CONST(GL_ACTIVE_STENCIL_FACE_EXT, 0x8911) \
  END()
#else
#define EXTENSION_GL_EXT_stencil_two_side(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_text_fragment_shader
#define GL_ATI_text_fragment_shader 1
#define EXTENSION_GL_ATI_text_fragment_shader(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_text_fragment_shader) \
  CONST(GL_TEXT_FRAGMENT_SHADER_ATI, 0x8200) \
  END()
#else
#define EXTENSION_GL_ATI_text_fragment_shader(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_client_storage
#define GL_APPLE_client_storage 1
#define EXTENSION_GL_APPLE_client_storage(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_client_storage) \
  CONST(GL_UNPACK_CLIENT_STORAGE_APPLE, 0x85B2) \
  END()
#else
#define EXTENSION_GL_APPLE_client_storage(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_element_array
#define GL_APPLE_element_array 1
#define EXTENSION_GL_APPLE_element_array(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_element_array) \
  FUNC(void, glElementPointerAPPLE, GLELEMENTPOINTERAPPLE, (GLenum type, const GLvoid * pointer)) \
  FUNC(void, glDrawElementArrayAPPLE, GLDRAWELEMENTARRAYAPPLE, (GLenum mode, GLint first, GLsizei count)) \
  FUNC(void, glDrawRangeElementArrayAPPLE, GLDRAWRANGEELEMENTARRAYAPPLE, (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count)) \
  FUNC(void, glMultiDrawElementArrayAPPLE, GLMULTIDRAWELEMENTARRAYAPPLE, (GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount)) \
  FUNC(void, glMultiDrawRangeElementArrayAPPLE, GLMULTIDRAWRANGEELEMENTARRAYAPPLE, (GLenum mode, GLuint start, GLuint end, const GLint * first, const GLsizei * count, GLsizei primcount)) \
  CONST(GL_ELEMENT_ARRAY_APPLE, 0x8768) \
  CONST(GL_ELEMENT_ARRAY_TYPE_APPLE, 0x8769) \
  CONST(GL_ELEMENT_ARRAY_POINTER_APPLE, 0x876A) \
  END()
#else
#define EXTENSION_GL_APPLE_element_array(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_fence
#define GL_APPLE_fence 1
#define EXTENSION_GL_APPLE_fence(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_fence) \
  FUNC(void, glGenFencesAPPLE, GLGENFENCESAPPLE, (GLsizei n, GLuint * fences)) \
  FUNC(void, glDeleteFencesAPPLE, GLDELETEFENCESAPPLE, (GLsizei n, const GLuint * fences)) \
  FUNC(void, glSetFenceAPPLE, GLSETFENCEAPPLE, (GLuint fence)) \
  FUNC(GLboolean, glIsFenceAPPLE, GLISFENCEAPPLE, (GLuint fence)) \
  FUNC(GLboolean, glTestFenceAPPLE, GLTESTFENCEAPPLE, (GLuint fence)) \
  FUNC(void, glFinishFenceAPPLE, GLFINISHFENCEAPPLE, (GLuint fence)) \
  FUNC(GLboolean, glTestObjectAPPLE, GLTESTOBJECTAPPLE, (GLenum object, GLuint name)) \
  FUNC(void, glFinishObjectAPPLE, GLFINISHOBJECTAPPLE, (GLenum object, GLint name)) \
  CONST(GL_DRAW_PIXELS_APPLE, 0x8A0A) \
  CONST(GL_FENCE_APPLE, 0x8A0B) \
  END()
#else
#define EXTENSION_GL_APPLE_fence(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_vertex_array_object
#define GL_APPLE_vertex_array_object 1
#define EXTENSION_GL_APPLE_vertex_array_object(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_vertex_array_object) \
  FUNC(void, glBindVertexArrayAPPLE, GLBINDVERTEXARRAYAPPLE, (GLuint array)) \
  FUNC(void, glDeleteVertexArraysAPPLE, GLDELETEVERTEXARRAYSAPPLE, (GLsizei n, const GLuint * arrays)) \
  FUNC(void, glGenVertexArraysAPPLE, GLGENVERTEXARRAYSAPPLE, (GLsizei n, const GLuint * arrays)) \
  FUNC(GLboolean, glIsVertexArrayAPPLE, GLISVERTEXARRAYAPPLE, (GLuint array)) \
  CONST(GL_VERTEX_ARRAY_BINDING_APPLE, 0x85B5) \
  END()
#else
#define EXTENSION_GL_APPLE_vertex_array_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_vertex_array_range
#define GL_APPLE_vertex_array_range 1
#define EXTENSION_GL_APPLE_vertex_array_range(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_vertex_array_range) \
  FUNC(void, glVertexArrayRangeAPPLE, GLVERTEXARRAYRANGEAPPLE, (GLsizei length, GLvoid * pointer)) \
  FUNC(void, glFlushVertexArrayRangeAPPLE, GLFLUSHVERTEXARRAYRANGEAPPLE, (GLsizei length, GLvoid * pointer)) \
  FUNC(void, glVertexArrayParameteriAPPLE, GLVERTEXARRAYPARAMETERIAPPLE, (GLenum pname, GLint param)) \
  CONST(GL_VERTEX_ARRAY_RANGE_APPLE, 0x851D) \
  CONST(GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE, 0x851E) \
  CONST(GL_VERTEX_ARRAY_STORAGE_HINT_APPLE, 0x851F) \
  CONST(GL_VERTEX_ARRAY_RANGE_POINTER_APPLE, 0x8521) \
  CONST(GL_STORAGE_CACHED_APPLE, 0x85BE) \
  CONST(GL_STORAGE_SHARED_APPLE, 0x85BF) \
  END()
#else
#define EXTENSION_GL_APPLE_vertex_array_range(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_APPLE_ycbcr_422
#define GL_APPLE_ycbcr_422 1
#define EXTENSION_GL_APPLE_ycbcr_422(NAME, FUNC, CONST, END) \
  NAME(GL_APPLE_ycbcr_422) \
  CONST(GL_YCBCR_422_APPLE, 0x85B9) \
  CONST(GL_UNSIGNED_SHORT_8_8_APPLE, 0x85BA) \
  CONST(GL_UNSIGNED_SHORT_8_8_REV_APPLE, 0x85BB) \
  END()
#else
#define EXTENSION_GL_APPLE_ycbcr_422(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_S3_s3tc
#define GL_S3_s3tc 1
#define EXTENSION_GL_S3_s3tc(NAME, FUNC, CONST, END) \
  NAME(GL_S3_s3tc) \
  CONST(GL_RGB_S3TC, 0x83A0) \
  CONST(GL_RGB4_S3TC, 0x83A1) \
  CONST(GL_RGBA_S3TC, 0x83A2) \
  CONST(GL_RGBA4_S3TC, 0x83A3) \
  END()
#else
#define EXTENSION_GL_S3_s3tc(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_draw_buffers
#define GL_ATI_draw_buffers 1
#define EXTENSION_GL_ATI_draw_buffers(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_draw_buffers) \
  FUNC(void, glDrawBuffersATI, GLDRAWBUFFERSATI, (GLsizei n, const GLenum * bufs)) \
  CONST(GL_MAX_DRAW_BUFFERS_ATI, 0x8824) \
  CONST(GL_DRAW_BUFFER0_ATI, 0x8825) \
  CONST(GL_DRAW_BUFFER1_ATI, 0x8826) \
  CONST(GL_DRAW_BUFFER2_ATI, 0x8827) \
  CONST(GL_DRAW_BUFFER3_ATI, 0x8828) \
  CONST(GL_DRAW_BUFFER4_ATI, 0x8829) \
  CONST(GL_DRAW_BUFFER5_ATI, 0x882A) \
  CONST(GL_DRAW_BUFFER6_ATI, 0x882B) \
  CONST(GL_DRAW_BUFFER7_ATI, 0x882C) \
  CONST(GL_DRAW_BUFFER8_ATI, 0x882D) \
  CONST(GL_DRAW_BUFFER9_ATI, 0x882E) \
  CONST(GL_DRAW_BUFFER10_ATI, 0x882F) \
  CONST(GL_DRAW_BUFFER11_ATI, 0x8830) \
  CONST(GL_DRAW_BUFFER12_ATI, 0x8831) \
  CONST(GL_DRAW_BUFFER13_ATI, 0x8832) \
  CONST(GL_DRAW_BUFFER14_ATI, 0x8833) \
  CONST(GL_DRAW_BUFFER15_ATI, 0x8834) \
  END()
#else
#define EXTENSION_GL_ATI_draw_buffers(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_pixel_format_float
#define GL_ATI_pixel_format_float 1
#define EXTENSION_GL_ATI_pixel_format_float(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_pixel_format_float) \
  CONST(GL_TYPE_RGBA_FLOAT_ATI, 0x8820) \
  CONST(GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI, 0x8835) \
  END()
#else
#define EXTENSION_GL_ATI_pixel_format_float(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_texture_env_combine3
#define GL_ATI_texture_env_combine3 1
#define EXTENSION_GL_ATI_texture_env_combine3(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_texture_env_combine3) \
  CONST(GL_MODULATE_ADD_ATI, 0x8744) \
  CONST(GL_MODULATE_SIGNED_ADD_ATI, 0x8745) \
  CONST(GL_MODULATE_SUBTRACT_ATI, 0x8746) \
  END()
#else
#define EXTENSION_GL_ATI_texture_env_combine3(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_texture_float
#define GL_ATI_texture_float 1
#define EXTENSION_GL_ATI_texture_float(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_texture_float) \
  CONST(GL_RGBA_FLOAT32_ATI, 0x8814) \
  CONST(GL_RGB_FLOAT32_ATI, 0x8815) \
  CONST(GL_ALPHA_FLOAT32_ATI, 0x8816) \
  CONST(GL_INTENSITY_FLOAT32_ATI, 0x8817) \
  CONST(GL_LUMINANCE_FLOAT32_ATI, 0x8818) \
  CONST(GL_LUMINANCE_ALPHA_FLOAT32_ATI, 0x8819) \
  CONST(GL_RGBA_FLOAT16_ATI, 0x881A) \
  CONST(GL_RGB_FLOAT16_ATI, 0x881B) \
  CONST(GL_ALPHA_FLOAT16_ATI, 0x881C) \
  CONST(GL_INTENSITY_FLOAT16_ATI, 0x881D) \
  CONST(GL_LUMINANCE_FLOAT16_ATI, 0x881E) \
  CONST(GL_LUMINANCE_ALPHA_FLOAT16_ATI, 0x881F) \
  END()
#else
#define EXTENSION_GL_ATI_texture_float(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_float_buffer
#define GL_NV_float_buffer 1
#define EXTENSION_GL_NV_float_buffer(NAME, FUNC, CONST, END) \
  NAME(GL_NV_float_buffer) \
  CONST(GL_FLOAT_R_NV, 0x8880) \
  CONST(GL_FLOAT_RG_NV, 0x8881) \
  CONST(GL_FLOAT_RGB_NV, 0x8882) \
  CONST(GL_FLOAT_RGBA_NV, 0x8883) \
  CONST(GL_FLOAT_R16_NV, 0x8884) \
  CONST(GL_FLOAT_R32_NV, 0x8885) \
  CONST(GL_FLOAT_RG16_NV, 0x8886) \
  CONST(GL_FLOAT_RG32_NV, 0x8887) \
  CONST(GL_FLOAT_RGB16_NV, 0x8888) \
  CONST(GL_FLOAT_RGB32_NV, 0x8889) \
  CONST(GL_FLOAT_RGBA16_NV, 0x888A) \
  CONST(GL_FLOAT_RGBA32_NV, 0x888B) \
  CONST(GL_TEXTURE_FLOAT_COMPONENTS_NV, 0x888C) \
  CONST(GL_FLOAT_CLEAR_COLOR_VALUE_NV, 0x888D) \
  CONST(GL_FLOAT_RGBA_MODE_NV, 0x888E) \
  END()
#else
#define EXTENSION_GL_NV_float_buffer(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_fragment_program
#define GL_NV_fragment_program 1
#define EXTENSION_GL_NV_fragment_program(NAME, FUNC, CONST, END) \
  NAME(GL_NV_fragment_program) \
  FUNC(void, glProgramNamedParameter4fNV, GLPROGRAMNAMEDPARAMETER4FNV, (GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
  FUNC(void, glProgramNamedParameter4dNV, GLPROGRAMNAMEDPARAMETER4DNV, (GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
  FUNC(void, glProgramNamedParameter4fvNV, GLPROGRAMNAMEDPARAMETER4FVNV, (GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)) \
  FUNC(void, glProgramNamedParameter4dvNV, GLPROGRAMNAMEDPARAMETER4DVNV, (GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)) \
  FUNC(void, glGetProgramNamedParameterfvNV, GLGETPROGRAMNAMEDPARAMETERFVNV, (GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)) \
  FUNC(void, glGetProgramNamedParameterdvNV, GLGETPROGRAMNAMEDPARAMETERDVNV, (GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)) \
  CONST(GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV, 0x8868) \
  CONST(GL_FRAGMENT_PROGRAM_NV, 0x8870) \
  CONST(GL_MAX_TEXTURE_COORDS_NV, 0x8871) \
  CONST(GL_MAX_TEXTURE_IMAGE_UNITS_NV, 0x8872) \
  CONST(GL_FRAGMENT_PROGRAM_BINDING_NV, 0x8873) \
  CONST(GL_PROGRAM_ERROR_STRING_NV, 0x8874) \
  END()
#else
#define EXTENSION_GL_NV_fragment_program(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_half_float
#define GL_NV_half_float 1
#define EXTENSION_GL_NV_half_float(NAME, FUNC, CONST, END) \
  NAME(GL_NV_half_float) \
  FUNC(void, glVertex2hNV, GLVERTEX2HNV, (GLhalfNV x, GLhalfNV y)) \
  FUNC(void, glVertex2hvNV, GLVERTEX2HVNV, (const GLhalfNV * v)) \
  FUNC(void, glVertex3hNV, GLVERTEX3HNV, (GLhalfNV x, GLhalfNV y, GLhalfNV z)) \
  FUNC(void, glVertex3hvNV, GLVERTEX3HVNV, (const GLhalfNV * v)) \
  FUNC(void, glVertex4hNV, GLVERTEX4HNV, (GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)) \
  FUNC(void, glVertex4hvNV, GLVERTEX4HVNV, (const GLhalfNV * v)) \
  FUNC(void, glNormal3hNV, GLNORMAL3HNV, (GLhalfNV nx, GLhalfNV ny, GLhalfNV nz)) \
  FUNC(void, glNormal3hvNV, GLNORMAL3HVNV, (const GLhalfNV * v)) \
  FUNC(void, glColor3hNV, GLCOLOR3HNV, (GLhalfNV red, GLhalfNV green, GLhalfNV blue)) \
  FUNC(void, glColor3hvNV, GLCOLOR3HVNV, (const GLhalfNV * v)) \
  FUNC(void, glColor4hNV, GLCOLOR4HNV, (GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha)) \
  FUNC(void, glColor4hvNV, GLCOLOR4HVNV, (const GLhalfNV * v)) \
  FUNC(void, glTexCoord1hNV, GLTEXCOORD1HNV, (GLhalfNV s)) \
  FUNC(void, glTexCoord1hvNV, GLTEXCOORD1HVNV, (const GLhalfNV * v)) \
  FUNC(void, glTexCoord2hNV, GLTEXCOORD2HNV, (GLhalfNV s, GLhalfNV t)) \
  FUNC(void, glTexCoord2hvNV, GLTEXCOORD2HVNV, (const GLhalfNV * v)) \
  FUNC(void, glTexCoord3hNV, GLTEXCOORD3HNV, (GLhalfNV s, GLhalfNV t, GLhalfNV r)) \
  FUNC(void, glTexCoord3hvNV, GLTEXCOORD3HVNV, (const GLhalfNV * v)) \
  FUNC(void, glTexCoord4hNV, GLTEXCOORD4HNV, (GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)) \
  FUNC(void, glTexCoord4hvNV, GLTEXCOORD4HVNV, (const GLhalfNV * v)) \
  FUNC(void, glMultiTexCoord1hNV, GLMULTITEXCOORD1HNV, (GLenum target, GLhalfNV s)) \
  FUNC(void, glMultiTexCoord1hvNV, GLMULTITEXCOORD1HVNV, (GLenum target, const GLhalfNV * v)) \
  FUNC(void, glMultiTexCoord2hNV, GLMULTITEXCOORD2HNV, (GLenum target, GLhalfNV s, GLhalfNV t)) \
  FUNC(void, glMultiTexCoord2hvNV, GLMULTITEXCOORD2HVNV, (GLenum target, const GLhalfNV * v)) \
  FUNC(void, glMultiTexCoord3hNV, GLMULTITEXCOORD3HNV, (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r)) \
  FUNC(void, glMultiTexCoord3hvNV, GLMULTITEXCOORD3HVNV, (GLenum target, const GLhalfNV * v)) \
  FUNC(void, glMultiTexCoord4hNV, GLMULTITEXCOORD4HNV, (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)) \
  FUNC(void, glMultiTexCoord4hvNV, GLMULTITEXCOORD4HVNV, (GLenum target, const GLhalfNV * v)) \
  FUNC(void, glFogCoordhNV, GLFOGCOORDHNV, (GLhalfNV fog)) \
  FUNC(void, glFogCoordhvNV, GLFOGCOORDHVNV, (const GLhalfNV * fog)) \
  FUNC(void, glSecondaryColor3hNV, GLSECONDARYCOLOR3HNV, (GLhalfNV red, GLhalfNV green, GLhalfNV blue)) \
  FUNC(void, glSecondaryColor3hvNV, GLSECONDARYCOLOR3HVNV, (const GLhalfNV * v)) \
  FUNC(void, glVertexWeighthNV, GLVERTEXWEIGHTHNV, (GLhalfNV weight)) \
  FUNC(void, glVertexWeighthvNV, GLVERTEXWEIGHTHVNV, (const GLhalfNV * weight)) \
  FUNC(void, glVertexAttrib1hNV, GLVERTEXATTRIB1HNV, (GLuint index, GLhalfNV x)) \
  FUNC(void, glVertexAttrib1hvNV, GLVERTEXATTRIB1HVNV, (GLuint index, const GLhalfNV * v)) \
  FUNC(void, glVertexAttrib2hNV, GLVERTEXATTRIB2HNV, (GLuint index, GLhalfNV x, GLhalfNV y)) \
  FUNC(void, glVertexAttrib2hvNV, GLVERTEXATTRIB2HVNV, (GLuint index, const GLhalfNV * v)) \
  FUNC(void, glVertexAttrib3hNV, GLVERTEXATTRIB3HNV, (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)) \
  FUNC(void, glVertexAttrib3hvNV, GLVERTEXATTRIB3HVNV, (GLuint index, const GLhalfNV * v)) \
  FUNC(void, glVertexAttrib4hNV, GLVERTEXATTRIB4HNV, (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)) \
  FUNC(void, glVertexAttrib4hvNV, GLVERTEXATTRIB4HVNV, (GLuint index, const GLhalfNV * v)) \
  FUNC(void, glVertexAttribs1hvNV, GLVERTEXATTRIBS1HVNV, (GLuint index, GLsizei n, const GLhalfNV * v)) \
  FUNC(void, glVertexAttribs2hvNV, GLVERTEXATTRIBS2HVNV, (GLuint index, GLsizei n, const GLhalfNV * v)) \
  FUNC(void, glVertexAttribs3hvNV, GLVERTEXATTRIBS3HVNV, (GLuint index, GLsizei n, const GLhalfNV * v)) \
  FUNC(void, glVertexAttribs4hvNV, GLVERTEXATTRIBS4HVNV, (GLuint index, GLsizei n, const GLhalfNV * v)) \
  CONST(GL_HALF_FLOAT_NV, 0x140B) \
  END()
#else
#define EXTENSION_GL_NV_half_float(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_pixel_data_range
#define GL_NV_pixel_data_range 1
#define EXTENSION_GL_NV_pixel_data_range(NAME, FUNC, CONST, END) \
  NAME(GL_NV_pixel_data_range) \
  FUNC(void, glPixelDataRangeNV, GLPIXELDATARANGENV, (GLenum target, GLsizei length, GLvoid * pointer)) \
  FUNC(void, glFlushPixelDataRangeNV, GLFLUSHPIXELDATARANGENV, (GLenum target)) \
  CONST(GL_WRITE_PIXEL_DATA_RANGE_NV, 0x8878) \
  CONST(GL_READ_PIXEL_DATA_RANGE_NV, 0x8879) \
  CONST(GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV, 0x887A) \
  CONST(GL_READ_PIXEL_DATA_RANGE_LENGTH_NV, 0x887B) \
  CONST(GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV, 0x887C) \
  CONST(GL_READ_PIXEL_DATA_RANGE_POINTER_NV, 0x887D) \
  END()
#else
#define EXTENSION_GL_NV_pixel_data_range(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_primitive_restart
#define GL_NV_primitive_restart 1
#define EXTENSION_GL_NV_primitive_restart(NAME, FUNC, CONST, END) \
  NAME(GL_NV_primitive_restart) \
  FUNC(void, glPrimitiveRestartNV, GLPRIMITIVERESTARTNV, ()) \
  FUNC(void, glPrimitiveRestartIndexNV, GLPRIMITIVERESTARTINDEXNV, (GLuint index)) \
  CONST(GL_PRIMITIVE_RESTART_NV, 0x8558) \
  CONST(GL_PRIMITIVE_RESTART_INDEX_NV, 0x8559) \
  END()
#else
#define EXTENSION_GL_NV_primitive_restart(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_texture_expand_normal
#define GL_NV_texture_expand_normal 1
#define EXTENSION_GL_NV_texture_expand_normal(NAME, FUNC, CONST, END) \
  NAME(GL_NV_texture_expand_normal) \
  CONST(GL_TEXTURE_UNSIGNED_REMAP_MODE_NV, 0x888F) \
  END()
#else
#define EXTENSION_GL_NV_texture_expand_normal(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_vertex_program2
#define GL_NV_vertex_program2 1
#define EXTENSION_GL_NV_vertex_program2(NAME, FUNC, CONST, END) \
  NAME(GL_NV_vertex_program2) \
  END()
#else
#define EXTENSION_GL_NV_vertex_program2(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_map_object_buffer
#define GL_ATI_map_object_buffer 1
#define EXTENSION_GL_ATI_map_object_buffer(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_map_object_buffer) \
  FUNC(GLvoid*, glMapObjectBufferATI, GLMAPOBJECTBUFFERATI, (GLuint buffer)) \
  FUNC(void, glUnmapObjectBufferATI, GLUNMAPOBJECTBUFFERATI, (GLuint buffer)) \
  END()
#else
#define EXTENSION_GL_ATI_map_object_buffer(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_separate_stencil
#define GL_ATI_separate_stencil 1
#define EXTENSION_GL_ATI_separate_stencil(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_separate_stencil) \
  FUNC(void, glStencilOpSeparateATI, GLSTENCILOPSEPARATEATI, (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)) \
  FUNC(void, glStencilFuncSeparateATI, GLSTENCILFUNCSEPARATEATI, (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)) \
  CONST(GL_STENCIL_BACK_FUNC_ATI, 0x8800) \
  CONST(GL_STENCIL_BACK_FAIL_ATI, 0x8801) \
  CONST(GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI, 0x8802) \
  CONST(GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI, 0x8803) \
  END()
#else
#define EXTENSION_GL_ATI_separate_stencil(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_ATI_vertex_attrib_array_object
#define GL_ATI_vertex_attrib_array_object 1
#define EXTENSION_GL_ATI_vertex_attrib_array_object(NAME, FUNC, CONST, END) \
  NAME(GL_ATI_vertex_attrib_array_object) \
  FUNC(void, glVertexAttribArrayObjectATI, GLVERTEXATTRIBARRAYOBJECTATI, (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset)) \
  FUNC(void, glGetVertexAttribArrayObjectfvATI, GLGETVERTEXATTRIBARRAYOBJECTFVATI, (GLuint index, GLenum pname, GLfloat * params)) \
  FUNC(void, glGetVertexAttribArrayObjectivATI, GLGETVERTEXATTRIBARRAYOBJECTIVATI, (GLuint index, GLenum pname, GLint * params)) \
  END()
#else
#define EXTENSION_GL_ATI_vertex_attrib_array_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_OES_read_format
#define GL_OES_read_format 1
#define EXTENSION_GL_OES_read_format(NAME, FUNC, CONST, END) \
  NAME(GL_OES_read_format) \
  CONST(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES, 0x8B9A) \
  CONST(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES, 0x8B9B) \
  END()
#else
#define EXTENSION_GL_OES_read_format(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_depth_bounds_test
#define GL_EXT_depth_bounds_test 1
#define EXTENSION_GL_EXT_depth_bounds_test(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_depth_bounds_test) \
  FUNC(void, glDepthBoundsEXT, GLDEPTHBOUNDSEXT, (GLclampd zmin, GLclampd zmax)) \
  CONST(GL_DEPTH_BOUNDS_TEST_EXT, 0x8890) \
  CONST(GL_DEPTH_BOUNDS_EXT, 0x8891) \
  END()
#else
#define EXTENSION_GL_EXT_depth_bounds_test(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_mirror_clamp
#define GL_EXT_texture_mirror_clamp 1
#define EXTENSION_GL_EXT_texture_mirror_clamp(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_mirror_clamp) \
  CONST(GL_MIRROR_CLAMP_EXT, 0x8742) \
  CONST(GL_MIRROR_CLAMP_TO_EDGE_EXT, 0x8743) \
  CONST(GL_MIRROR_CLAMP_TO_BORDER_EXT, 0x8912) \
  END()
#else
#define EXTENSION_GL_EXT_texture_mirror_clamp(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_blend_equation_separate
#define GL_EXT_blend_equation_separate 1
#define EXTENSION_GL_EXT_blend_equation_separate(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_blend_equation_separate) \
  FUNC(void, glBlendEquationSeparateEXT, GLBLENDEQUATIONSEPARATEEXT, (GLenum modeRGB, GLenum modeAlpha)) \
  CONST(GL_BLEND_EQUATION_RGB_EXT, GL_BLEND_EQUATION) \
  CONST(GL_BLEND_EQUATION_ALPHA_EXT, 0x883D) \
  END()
#else
#define EXTENSION_GL_EXT_blend_equation_separate(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_MESA_pack_invert
#define GL_MESA_pack_invert 1
#define EXTENSION_GL_MESA_pack_invert(NAME, FUNC, CONST, END) \
  NAME(GL_MESA_pack_invert) \
  CONST(GL_PACK_INVERT_MESA, 0x8758) \
  END()
#else
#define EXTENSION_GL_MESA_pack_invert(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_MESA_ycbcr_texture
#define GL_MESA_ycbcr_texture 1
#define EXTENSION_GL_MESA_ycbcr_texture(NAME, FUNC, CONST, END) \
  NAME(GL_MESA_ycbcr_texture) \
  CONST(GL_UNSIGNED_SHORT_8_8_MESA, 0x85BA) \
  CONST(GL_UNSIGNED_SHORT_8_8_REV_MESA, 0x85BB) \
  CONST(GL_YCBCR_MESA, 0x8757) \
  END()
#else
#define EXTENSION_GL_MESA_ycbcr_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_pixel_buffer_object
#define GL_EXT_pixel_buffer_object 1
#define EXTENSION_GL_EXT_pixel_buffer_object(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_pixel_buffer_object) \
  CONST(GL_PIXEL_PACK_BUFFER_EXT, 0x88EB) \
  CONST(GL_PIXEL_UNPACK_BUFFER_EXT, 0x88EC) \
  CONST(GL_PIXEL_PACK_BUFFER_BINDING_EXT, 0x88ED) \
  CONST(GL_PIXEL_UNPACK_BUFFER_BINDING_EXT, 0x88EF) \
  END()
#else
#define EXTENSION_GL_EXT_pixel_buffer_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_fragment_program_option
#define GL_NV_fragment_program_option 1
#define EXTENSION_GL_NV_fragment_program_option(NAME, FUNC, CONST, END) \
  NAME(GL_NV_fragment_program_option) \
  END()
#else
#define EXTENSION_GL_NV_fragment_program_option(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_fragment_program2
#define GL_NV_fragment_program2 1
#define EXTENSION_GL_NV_fragment_program2(NAME, FUNC, CONST, END) \
  NAME(GL_NV_fragment_program2) \
  CONST(GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV, 0x88F4) \
  CONST(GL_MAX_PROGRAM_CALL_DEPTH_NV, 0x88F5) \
  CONST(GL_MAX_PROGRAM_IF_DEPTH_NV, 0x88F6) \
  CONST(GL_MAX_PROGRAM_LOOP_DEPTH_NV, 0x88F7) \
  CONST(GL_MAX_PROGRAM_LOOP_COUNT_NV, 0x88F8) \
  END()
#else
#define EXTENSION_GL_NV_fragment_program2(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_vertex_program2_option
#define GL_NV_vertex_program2_option 1
#define EXTENSION_GL_NV_vertex_program2_option(NAME, FUNC, CONST, END) \
  NAME(GL_NV_vertex_program2_option) \
  END()
#else
#define EXTENSION_GL_NV_vertex_program2_option(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_vertex_program3
#define GL_NV_vertex_program3 1
#define EXTENSION_GL_NV_vertex_program3(NAME, FUNC, CONST, END) \
  NAME(GL_NV_vertex_program3) \
  END()
#else
#define EXTENSION_GL_NV_vertex_program3(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_framebuffer_object
#define GL_EXT_framebuffer_object 1
#define EXTENSION_GL_EXT_framebuffer_object(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_framebuffer_object) \
  FUNC(GLboolean, glIsRenderbufferEXT, GLISRENDERBUFFEREXT, (GLuint renderbuffer)) \
  FUNC(void, glBindRenderbufferEXT, GLBINDRENDERBUFFEREXT, (GLenum target, GLuint renderbuffer)) \
  FUNC(void, glDeleteRenderbuffersEXT, GLDELETERENDERBUFFERSEXT, (GLsizei n, const GLuint * renderbuffers)) \
  FUNC(void, glGenRenderbuffersEXT, GLGENRENDERBUFFERSEXT, (GLsizei n, GLuint * renderbuffers)) \
  FUNC(void, glRenderbufferStorageEXT, GLRENDERBUFFERSTORAGEEXT, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)) \
  FUNC(void, glGetRenderbufferParameterivEXT, GLGETRENDERBUFFERPARAMETERIVEXT, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(GLboolean, glIsFramebufferEXT, GLISFRAMEBUFFEREXT, (GLuint framebuffer)) \
  FUNC(void, glBindFramebufferEXT, GLBINDFRAMEBUFFEREXT, (GLenum target, GLuint framebuffer)) \
  FUNC(void, glDeleteFramebuffersEXT, GLDELETEFRAMEBUFFERSEXT, (GLsizei n, const GLuint * framebuffers)) \
  FUNC(void, glGenFramebuffersEXT, GLGENFRAMEBUFFERSEXT, (GLsizei n, GLuint * framebuffers)) \
  FUNC(GLenum, glCheckFramebufferStatusEXT, GLCHECKFRAMEBUFFERSTATUSEXT, (GLenum target)) \
  FUNC(void, glFramebufferTexture1DEXT, GLFRAMEBUFFERTEXTURE1DEXT, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) \
  FUNC(void, glFramebufferTexture2DEXT, GLFRAMEBUFFERTEXTURE2DEXT, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) \
  FUNC(void, glFramebufferTexture3DEXT, GLFRAMEBUFFERTEXTURE3DEXT, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)) \
  FUNC(void, glFramebufferRenderbufferEXT, GLFRAMEBUFFERRENDERBUFFEREXT, (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)) \
  FUNC(void, glGetFramebufferAttachmentParameterivEXT, GLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXT, (GLenum target, GLenum attachment, GLenum pname, GLint * params)) \
  FUNC(void, glGenerateMipmapEXT, GLGENERATEMIPMAPEXT, (GLenum target)) \
  CONST(GL_INVALID_FRAMEBUFFER_OPERATION_EXT, 0x0506) \
  CONST(GL_MAX_RENDERBUFFER_SIZE_EXT, 0x84E8) \
  CONST(GL_FRAMEBUFFER_BINDING_EXT, 0x8CA6) \
  CONST(GL_RENDERBUFFER_BINDING_EXT, 0x8CA7) \
  CONST(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, 0x8CD0) \
  CONST(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, 0x8CD1) \
  CONST(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, 0x8CD2) \
  CONST(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT, 0x8CD3) \
  CONST(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT, 0x8CD4) \
  CONST(GL_FRAMEBUFFER_COMPLETE_EXT, 0x8CD5) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT, 0x8CD6) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT, 0x8CD7) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT, 0x8CD8) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT, 0x8CD9) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT, 0x8CDA) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT, 0x8CDB) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT, 0x8CDC) \
  CONST(GL_FRAMEBUFFER_UNSUPPORTED_EXT, 0x8CDD) \
  CONST(GL_MAX_COLOR_ATTACHMENTS_EXT, 0x8CDF) \
  CONST(GL_COLOR_ATTACHMENT0_EXT, 0x8CE0) \
  CONST(GL_COLOR_ATTACHMENT1_EXT, 0x8CE1) \
  CONST(GL_COLOR_ATTACHMENT2_EXT, 0x8CE2) \
  CONST(GL_COLOR_ATTACHMENT3_EXT, 0x8CE3) \
  CONST(GL_COLOR_ATTACHMENT4_EXT, 0x8CE4) \
  CONST(GL_COLOR_ATTACHMENT5_EXT, 0x8CE5) \
  CONST(GL_COLOR_ATTACHMENT6_EXT, 0x8CE6) \
  CONST(GL_COLOR_ATTACHMENT7_EXT, 0x8CE7) \
  CONST(GL_COLOR_ATTACHMENT8_EXT, 0x8CE8) \
  CONST(GL_COLOR_ATTACHMENT9_EXT, 0x8CE9) \
  CONST(GL_COLOR_ATTACHMENT10_EXT, 0x8CEA) \
  CONST(GL_COLOR_ATTACHMENT11_EXT, 0x8CEB) \
  CONST(GL_COLOR_ATTACHMENT12_EXT, 0x8CEC) \
  CONST(GL_COLOR_ATTACHMENT13_EXT, 0x8CED) \
  CONST(GL_COLOR_ATTACHMENT14_EXT, 0x8CEE) \
  CONST(GL_COLOR_ATTACHMENT15_EXT, 0x8CEF) \
  CONST(GL_DEPTH_ATTACHMENT_EXT, 0x8D00) \
  CONST(GL_STENCIL_ATTACHMENT_EXT, 0x8D20) \
  CONST(GL_FRAMEBUFFER_EXT, 0x8D40) \
  CONST(GL_RENDERBUFFER_EXT, 0x8D41) \
  CONST(GL_RENDERBUFFER_WIDTH_EXT, 0x8D42) \
  CONST(GL_RENDERBUFFER_HEIGHT_EXT, 0x8D43) \
  CONST(GL_RENDERBUFFER_INTERNAL_FORMAT_EXT, 0x8D44) \
  CONST(GL_STENCIL_INDEX_EXT, 0x8D45) \
  CONST(GL_STENCIL_INDEX1_EXT, 0x8D46) \
  CONST(GL_STENCIL_INDEX4_EXT, 0x8D47) \
  CONST(GL_STENCIL_INDEX8_EXT, 0x8D48) \
  CONST(GL_STENCIL_INDEX16_EXT, 0x8D49) \
  CONST(GL_RENDERBUFFER_RED_SIZE_EXT, 0x8D50) \
  CONST(GL_RENDERBUFFER_GREEN_SIZE_EXT, 0x8D51) \
  CONST(GL_RENDERBUFFER_BLUE_SIZE_EXT, 0x8D52) \
  CONST(GL_RENDERBUFFER_ALPHA_SIZE_EXT, 0x8D53) \
  CONST(GL_RENDERBUFFER_DEPTH_SIZE_EXT, 0x8D54) \
  CONST(GL_RENDERBUFFER_STENCIL_SIZE_EXT, 0x8D55) \
  END()
#else
#define EXTENSION_GL_EXT_framebuffer_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_GREMEDY_string_marker
#define GL_GREMEDY_string_marker 1
#define EXTENSION_GL_GREMEDY_string_marker(NAME, FUNC, CONST, END) \
  NAME(GL_GREMEDY_string_marker) \
  FUNC(void, glStringMarkerGREMEDY, GLSTRINGMARKERGREMEDY, (GLsizei len, const GLvoid * string)) \
  END()
#else
#define EXTENSION_GL_GREMEDY_string_marker(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_Cg_shader
#define GL_EXT_Cg_shader 1
#define EXTENSION_GL_EXT_Cg_shader(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_Cg_shader) \
  CONST(GL_CG_VERTEX_SHADER_EXT, 0x890E) \
  CONST(GL_CG_FRAGMENT_SHADER_EXT, 0x890F) \
  END()
#else
#define EXTENSION_GL_EXT_Cg_shader(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_timer_query
#define GL_EXT_timer_query 1
#define EXTENSION_GL_EXT_timer_query(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_timer_query) \
  FUNC(void, glGetQueryObjecti64vEXT, GLGETQUERYOBJECTI64VEXT, (GLuint id, GLenum pname, GLint64EXT * params)) \
  FUNC(void, glGetQueryObjectui64vEXT, GLGETQUERYOBJECTUI64VEXT, (GLuint id, GLenum pname, GLuint64EXT * params)) \
  CONST(GL_TIME_ELAPSED_EXT, 0x88BF) \
  END()
#else
#define EXTENSION_GL_EXT_timer_query(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_buffer_object
#define GL_EXT_texture_buffer_object 1
#define EXTENSION_GL_EXT_texture_buffer_object(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_buffer_object) \
  FUNC(void, glTexBufferEXT, GLTEXBUFFEREXT, (GLenum target, GLenum internalformat, GLuint buffer)) \
  CONST(GL_TEXTURE_BUFFER_EXT, 0x8C2A) \
  CONST(GL_MAX_TEXTURE_BUFFER_SIZE_EXT, 0x8C2B) \
  CONST(GL_TEXTURE_BINDING_BUFFER_EXT, 0x8C2C) \
  CONST(GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT, 0x8C2D) \
  CONST(GL_TEXTURE_BUFFER_FORMAT_EXT, 0x8C2E) \
  END()
#else
#define EXTENSION_GL_EXT_texture_buffer_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_gpu_shader4
#define GL_EXT_gpu_shader4 1
#define EXTENSION_GL_EXT_gpu_shader4(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_gpu_shader4) \
  FUNC(void, glGetUniformuivEXT, GLGETUNIFORMUIVEXT, (GLuint program, GLint location, GLuint * params)) \
  FUNC(void, glBindFragDataLocationEXT, GLBINDFRAGDATALOCATIONEXT, (GLuint program, GLuint color, const GLchar * name)) \
  FUNC(GLint, glGetFragDataLocationEXT, GLGETFRAGDATALOCATIONEXT, (GLuint program, const GLchar * name)) \
  FUNC(void, glUniform1uiEXT, GLUNIFORM1UIEXT, (GLint location, GLuint v0)) \
  FUNC(void, glUniform2uiEXT, GLUNIFORM2UIEXT, (GLint location, GLuint v0, GLuint v1)) \
  FUNC(void, glUniform3uiEXT, GLUNIFORM3UIEXT, (GLint location, GLuint v0, GLuint v1, GLuint v2)) \
  FUNC(void, glUniform4uiEXT, GLUNIFORM4UIEXT, (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)) \
  FUNC(void, glUniform1uivEXT, GLUNIFORM1UIVEXT, (GLint location, GLsizei count, const GLuint * value)) \
  FUNC(void, glUniform2uivEXT, GLUNIFORM2UIVEXT, (GLint location, GLsizei count, const GLuint * value)) \
  FUNC(void, glUniform3uivEXT, GLUNIFORM3UIVEXT, (GLint location, GLsizei count, const GLuint * value)) \
  FUNC(void, glUniform4uivEXT, GLUNIFORM4UIVEXT, (GLint location, GLsizei count, const GLuint * value)) \
  FUNC(void, glVertexAttribI1iEXT, GLVERTEXATTRIBI1IEXT, (GLuint index, GLint x)) \
  FUNC(void, glVertexAttribI2iEXT, GLVERTEXATTRIBI2IEXT, (GLuint index, GLint x, GLint y)) \
  FUNC(void, glVertexAttribI3iEXT, GLVERTEXATTRIBI3IEXT, (GLuint index, GLint x, GLint y, GLint z)) \
  FUNC(void, glVertexAttribI4iEXT, GLVERTEXATTRIBI4IEXT, (GLuint index, GLint x, GLint y, GLint z, GLint w)) \
  FUNC(void, glVertexAttribI1uiEXT, GLVERTEXATTRIBI1UIEXT, (GLuint index, GLuint x)) \
  FUNC(void, glVertexAttribI2uiEXT, GLVERTEXATTRIBI2UIEXT, (GLuint index, GLuint x, GLuint y)) \
  FUNC(void, glVertexAttribI3uiEXT, GLVERTEXATTRIBI3UIEXT, (GLuint index, GLuint x, GLuint y, GLuint z)) \
  FUNC(void, glVertexAttribI4uiEXT, GLVERTEXATTRIBI4UIEXT, (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
  FUNC(void, glVertexAttribI1ivEXT, GLVERTEXATTRIBI1IVEXT, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttribI2ivEXT, GLVERTEXATTRIBI2IVEXT, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttribI3ivEXT, GLVERTEXATTRIBI3IVEXT, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttribI4ivEXT, GLVERTEXATTRIBI4IVEXT, (GLuint index, const GLint * v)) \
  FUNC(void, glVertexAttribI1uivEXT, GLVERTEXATTRIBI1UIVEXT, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttribI2uivEXT, GLVERTEXATTRIBI2UIVEXT, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttribI3uivEXT, GLVERTEXATTRIBI3UIVEXT, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttribI4uivEXT, GLVERTEXATTRIBI4UIVEXT, (GLuint index, const GLuint * v)) \
  FUNC(void, glVertexAttribI4bvEXT, GLVERTEXATTRIBI4BVEXT, (GLuint index, const GLbyte * v)) \
  FUNC(void, glVertexAttribI4svEXT, GLVERTEXATTRIBI4SVEXT, (GLuint index, const GLshort * v)) \
  FUNC(void, glVertexAttribI4ubvEXT, GLVERTEXATTRIBI4UBVEXT, (GLuint index, const GLubyte * v)) \
  FUNC(void, glVertexAttribI4usvEXT, GLVERTEXATTRIBI4USVEXT, (GLuint index, const GLushort * v)) \
  FUNC(void, glVertexAttribIPointerEXT, GLVERTEXATTRIBIPOINTEREXT, (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)) \
  FUNC(void, glGetVertexAttribIivEXT, GLGETVERTEXATTRIBIIVEXT, (GLuint index, GLenum pname, GLint * params)) \
  FUNC(void, glGetVertexAttribIuivEXT, GLGETVERTEXATTRIBIUIVEXT, (GLuint index, GLenum pname, GLuint * params)) \
  CONST(GL_SAMPLER_1D_ARRAY_EXT, 0x8DC0) \
  CONST(GL_SAMPLER_2D_ARRAY_EXT, 0x8DC1) \
  CONST(GL_SAMPLER_BUFFER_EXT, 0x8DC2) \
  CONST(GL_SAMPLER_1D_ARRAY_SHADOW_EXT, 0x8DC3) \
  CONST(GL_SAMPLER_2D_ARRAY_SHADOW_EXT, 0x8DC4) \
  CONST(GL_SAMPLER_CUBE_SHADOW_EXT, 0x8DC5) \
  CONST(GL_UNSIGNED_INT_VEC2_EXT, 0x8DC6) \
  CONST(GL_UNSIGNED_INT_VEC3_EXT, 0x8DC7) \
  CONST(GL_UNSIGNED_INT_VEC4_EXT, 0x8DC8) \
  CONST(GL_INT_SAMPLER_1D_EXT, 0x8DC9) \
  CONST(GL_INT_SAMPLER_2D_EXT, 0x8DCA) \
  CONST(GL_INT_SAMPLER_3D_EXT, 0x8DCB) \
  CONST(GL_INT_SAMPLER_CUBE_EXT, 0x8DCC) \
  CONST(GL_INT_SAMPLER_2D_RECT_EXT, 0x8DCD) \
  CONST(GL_INT_SAMPLER_1D_ARRAY_EXT, 0x8DCE) \
  CONST(GL_INT_SAMPLER_2D_ARRAY_EXT, 0x8DCF) \
  CONST(GL_INT_SAMPLER_BUFFER_EXT, 0x8DD0) \
  CONST(GL_UNSIGNED_INT_SAMPLER_1D_EXT, 0x8DD1) \
  CONST(GL_UNSIGNED_INT_SAMPLER_2D_EXT, 0x8DD2) \
  CONST(GL_UNSIGNED_INT_SAMPLER_3D_EXT, 0x8DD3) \
  CONST(GL_UNSIGNED_INT_SAMPLER_CUBE_EXT, 0x8DD4) \
  CONST(GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT, 0x8DD5) \
  CONST(GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT, 0x8DD6) \
  CONST(GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT, 0x8DD7) \
  CONST(GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT, 0x8DD8) \
  CONST(GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT, 0x88FD) \
  END()
#else
#define EXTENSION_GL_EXT_gpu_shader4(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_geometry_shader4
#define GL_EXT_geometry_shader4 1
#define EXTENSION_GL_EXT_geometry_shader4(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_geometry_shader4) \
  FUNC(void, glProgramParameteriEXT, GLPROGRAMPARAMETERIEXT, (GLuint program, GLenum pname, GLint value)) \
  FUNC(void, glFramebufferTextureEXT, GLFRAMEBUFFERTEXTUREEXT, (GLenum target, GLenum attachment, GLuint texture, GLint level)) \
  FUNC(void, glFramebufferTextureLayerEXT, GLFRAMEBUFFERTEXTURELAYEREXT, (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)) \
  FUNC(void, glFramebufferTextureFaceEXT, GLFRAMEBUFFERTEXTUREFACEEXT, (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)) \
  CONST(GL_GEOMETRY_SHADER_EXT, 0x8DD9) \
  CONST(GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT, 0x8DDD) \
  CONST(GL_MAX_VERTEX_VARYING_COMPONENTS_EXT, 0x8DDE) \
  CONST(GL_MAX_VARYING_COMPONENTS_EXT, 0x8B4B) \
  CONST(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT, 0x8DDF) \
  CONST(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, 0x8DE0) \
  CONST(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT, 0x8DE1) \
  CONST(GL_GEOMETRY_VERTICES_OUT_EXT, 0x8DDA) \
  CONST(GL_GEOMETRY_INPUT_TYPE_EXT, 0x8DDB) \
  CONST(GL_GEOMETRY_OUTPUT_TYPE_EXT, 0x8DDC) \
  CONST(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT, 0x8C29) \
  CONST(GL_LINES_ADJACENCY_EXT, 0xA) \
  CONST(GL_LINE_STRIP_ADJACENCY_EXT, 0xB) \
  CONST(GL_TRIANGLES_ADJACENCY_EXT, 0xC) \
  CONST(GL_TRIANGLE_STRIP_ADJACENCY_EXT, 0xD) \
  CONST(GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT, 0x8DA7) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT, 0x8DA8) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT, 0x8DA9) \
  CONST(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT, 0x8CD4) \
  CONST(GL_PROGRAM_POINT_SIZE_EXT, 0x8642) \
  END()
#else
#define EXTENSION_GL_EXT_geometry_shader4(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_bindable_uniform
#define GL_EXT_bindable_uniform 1
#define EXTENSION_GL_EXT_bindable_uniform(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_bindable_uniform) \
  FUNC(void, glUniformBufferEXT, GLUNIFORMBUFFEREXT, (GLuint program, GLint location, GLuint buffer)) \
  FUNC(GLint, glGetUniformBufferSizeEXT, GLGETUNIFORMBUFFERSIZEEXT, (GLuint program, GLint location)) \
  FUNC(GLintptr, glGetUniformOffsetEXT, GLGETUNIFORMOFFSETEXT, (GLuint program, GLint location)) \
  CONST(GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT, 0x8DE2) \
  CONST(GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT, 0x8DE3) \
  CONST(GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT, 0x8DE4) \
  CONST(GL_MAX_BINDABLE_UNIFORM_SIZE_EXT, 0x8DED) \
  CONST(GL_UNIFORM_BUFFER_EXT, 0x8DEE) \
  CONST(GL_UNIFORM_BUFFER_BINDING_EXT, 0x8DEF) \
  END()
#else
#define EXTENSION_GL_EXT_bindable_uniform(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_framebuffer_sRGB
#define GL_EXT_framebuffer_sRGB 1
#define EXTENSION_GL_EXT_framebuffer_sRGB(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_framebuffer_sRGB) \
  CONST(GL_FRAMEBUFFER_SRGB_EXT, 0x8DB9) \
  CONST(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, 0x8DBA) \
  END()
#else
#define EXTENSION_GL_EXT_framebuffer_sRGB(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_shared_exponent
#define GL_EXT_texture_shared_exponent 1
#define EXTENSION_GL_EXT_texture_shared_exponent(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_shared_exponent) \
  CONST(GL_RGB9_E5_EXT, 0x8C3D) \
  CONST(GL_UNSIGNED_INT_5_9_9_9_REV_EXT, 0x8C3E) \
  CONST(GL_TEXTURE_SHARED_SIZE_EXT, 0x8C3F) \
  END()
#else
#define EXTENSION_GL_EXT_texture_shared_exponent(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_packed_float
#define GL_EXT_packed_float 1
#define EXTENSION_GL_EXT_packed_float(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_packed_float) \
  CONST(GL_R11F_G11F_B10F_EXT, 0x8C3A) \
  CONST(GL_UNSIGNED_INT_10F_11F_11F_REV_EXT, 0x8C3B) \
  CONST(GL_RGBA_SIGNED_COMPONENTS_EXT, 0x8C3C) \
  END()
#else
#define EXTENSION_GL_EXT_packed_float(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_array
#define GL_EXT_texture_array 1
#define EXTENSION_GL_EXT_texture_array(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_array) \
  CONST(GL_TEXTURE_1D_ARRAY_EXT, 0x8C18) \
  CONST(GL_PROXY_TEXTURE_1D_ARRAY_EXT, 0x8C19) \
  CONST(GL_TEXTURE_2D_ARRAY_EXT, 0x8C1A) \
  CONST(GL_PROXY_TEXTURE_2D_ARRAY_EXT, 0x8C1B) \
  CONST(GL_TEXTURE_BINDING_1D_ARRAY_EXT, 0x8C1C) \
  CONST(GL_TEXTURE_BINDING_2D_ARRAY_EXT, 0x8C1D) \
  CONST(GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, 0x88FF) \
  CONST(GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT, 0x884E) \
  END()
#else
#define EXTENSION_GL_EXT_texture_array(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_integer
#define GL_EXT_texture_integer 1
#define EXTENSION_GL_EXT_texture_integer(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_integer) \
  FUNC(void, glTexParameterIivEXT, GLTEXPARAMETERIIVEXT, (GLenum target, GLenum pname, const GLint * params)) \
  FUNC(void, glTexParameterIuivEXT, GLTEXPARAMETERIUIVEXT, (GLenum target, GLenum pname, const GLuint * params)) \
  FUNC(void, glGetTexParameterIivEXT, GLGETTEXPARAMETERIIVEXT, (GLenum target, GLenum pname, GLint * params)) \
  FUNC(void, glGetTexParameterIuivEXT, GLGETTEXPARAMETERIUIVEXT, (GLenum target, GLenum pname, GLuint * params)) \
  FUNC(void, glClearColorIiEXT, GLCLEARCOLORIIEXT, (GLint red, GLint green, GLint blue, GLint alpha)) \
  FUNC(void, glClearColorIuiEXT, GLCLEARCOLORIUIEXT, (GLuint red, GLuint green, GLuint blue, GLuint alpha)) \
  CONST(GL_RGBA32UI_EXT, 0x8D70) \
  CONST(GL_RGB32UI_EXT, 0x8D71) \
  CONST(GL_ALPHA32UI_EXT, 0x8D72) \
  CONST(GL_INTENSITY32UI_EXT, 0x8D73) \
  CONST(GL_LUMINANCE32UI_EXT, 0x8D74) \
  CONST(GL_LUMINANCE_ALPHA32UI_EXT, 0x8D75) \
  CONST(GL_RGBA16UI_EXT, 0x8D76) \
  CONST(GL_RGB16UI_EXT, 0x8D77) \
  CONST(GL_ALPHA16UI_EXT, 0x8D78) \
  CONST(GL_INTENSITY16UI_EXT, 0x8D79) \
  CONST(GL_LUMINANCE16UI_EXT, 0x8D7A) \
  CONST(GL_LUMINANCE_ALPHA16UI_EXT, 0x8D7B) \
  CONST(GL_RGBA8UI_EXT, 0x8D7C) \
  CONST(GL_RGB8UI_EXT, 0x8D7D) \
  CONST(GL_ALPHA8UI_EXT, 0x8D7E) \
  CONST(GL_INTENSITY8UI_EXT, 0x8D7F) \
  CONST(GL_LUMINANCE8UI_EXT, 0x8D80) \
  CONST(GL_LUMINANCE_ALPHA8UI_EXT, 0x8D81) \
  CONST(GL_RGBA32I_EXT, 0x8D82) \
  CONST(GL_RGB32I_EXT, 0x8D83) \
  CONST(GL_ALPHA32I_EXT, 0x8D84) \
  CONST(GL_INTENSITY32I_EXT, 0x8D85) \
  CONST(GL_LUMINANCE32I_EXT, 0x8D86) \
  CONST(GL_LUMINANCE_ALPHA32I_EXT, 0x8D87) \
  CONST(GL_RGBA16I_EXT, 0x8D88) \
  CONST(GL_RGB16I_EXT, 0x8D89) \
  CONST(GL_ALPHA16I_EXT, 0x8D8A) \
  CONST(GL_INTENSITY16I_EXT, 0x8D8B) \
  CONST(GL_LUMINANCE16I_EXT, 0x8D8C) \
  CONST(GL_LUMINANCE_ALPHA16I_EXT, 0x8D8D) \
  CONST(GL_RGBA8I_EXT, 0x8D8E) \
  CONST(GL_RGB8I_EXT, 0x8D8F) \
  CONST(GL_ALPHA8I_EXT, 0x8D90) \
  CONST(GL_INTENSITY8I_EXT, 0x8D91) \
  CONST(GL_LUMINANCE8I_EXT, 0x8D92) \
  CONST(GL_LUMINANCE_ALPHA8I_EXT, 0x8D93) \
  CONST(GL_RED_INTEGER_EXT, 0x8D94) \
  CONST(GL_GREEN_INTEGER_EXT, 0x8D95) \
  CONST(GL_BLUE_INTEGER_EXT, 0x8D96) \
  CONST(GL_ALPHA_INTEGER_EXT, 0x8D97) \
  CONST(GL_RGB_INTEGER_EXT, 0x8D98) \
  CONST(GL_RGBA_INTEGER_EXT, 0x8D99) \
  CONST(GL_BGR_INTEGER_EXT, 0x8D9A) \
  CONST(GL_BGRA_INTEGER_EXT, 0x8D9B) \
  CONST(GL_LUMINANCE_INTEGER_EXT, 0x8D9C) \
  CONST(GL_LUMINANCE_ALPHA_INTEGER_EXT, 0x8D9D) \
  CONST(GL_RGBA_INTEGER_MODE_EXT, 0x8D9E) \
  END()
#else
#define EXTENSION_GL_EXT_texture_integer(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_depth_buffer_float
#define GL_NV_depth_buffer_float 1
#define EXTENSION_GL_NV_depth_buffer_float(NAME, FUNC, CONST, END) \
  NAME(GL_NV_depth_buffer_float) \
  FUNC(void, glDepthRangedNV, GLDEPTHRANGEDNV, (GLdouble zNear, GLdouble zFar)) \
  FUNC(void, glClearDepthdNV, GLCLEARDEPTHDNV, (GLdouble depth)) \
  FUNC(void, glDepthBoundsdNV, GLDEPTHBOUNDSDNV, (GLdouble zmin, GLdouble zmax)) \
  CONST(GL_DEPTH_COMPONENT32F_NV, 0x8DAB) \
  CONST(GL_DEPTH32F_STENCIL8_NV, 0x8DAC) \
  CONST(GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV, 0x8DAD) \
  CONST(GL_DEPTH_BUFFER_FLOAT_MODE_NV, 0x8DAF) \
  END()
#else
#define EXTENSION_GL_NV_depth_buffer_float(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_compression_latc
#define GL_EXT_texture_compression_latc 1
#define EXTENSION_GL_EXT_texture_compression_latc(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_compression_latc) \
  CONST(GL_COMPRESSED_LUMINANCE_LATC1_EXT, 0x8C70) \
  CONST(GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, 0x8C71) \
  CONST(GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, 0x8C72) \
  CONST(GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, 0x8C73) \
  END()
#else
#define EXTENSION_GL_EXT_texture_compression_latc(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_transform_feedback
#define GL_NV_transform_feedback 1
#define EXTENSION_GL_NV_transform_feedback(NAME, FUNC, CONST, END) \
  NAME(GL_NV_transform_feedback) \
  FUNC(void, glBeginTransformFeedbackNV, GLBEGINTRANSFORMFEEDBACKNV, (GLenum primitiveMode)) \
  FUNC(void, glEndTransformFeedbackNV, GLENDTRANSFORMFEEDBACKNV, ()) \
  FUNC(void, glTransformFeedbackAttribsNV, GLTRANSFORMFEEDBACKATTRIBSNV, (GLuint count, const GLint * attribs, GLenum bufferMode)) \
  FUNC(void, glBindBufferRangeNV, GLBINDBUFFERRANGENV, (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)) \
  FUNC(void, glBindBufferOffsetNV, GLBINDBUFFEROFFSETNV, (GLenum target, GLuint index, GLuint buffer, GLintptr offset)) \
  FUNC(void, glBindBufferBaseNV, GLBINDBUFFERBASENV, (GLenum target, GLuint index, GLuint buffer)) \
  FUNC(void, glTransformFeedbackVaryingsNV, GLTRANSFORMFEEDBACKVARYINGSNV, (GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode)) \
  FUNC(void, glActiveVaryingNV, GLACTIVEVARYINGNV, (GLuint program, const GLchar * name)) \
  FUNC(GLint, glGetVaryingLocationNV, GLGETVARYINGLOCATIONNV, (GLuint program, const GLchar * name)) \
  FUNC(void, glGetActiveVaryingNV, GLGETACTIVEVARYINGNV, (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)) \
  FUNC(void, glGetTransformFeedbackVaryingNV, GLGETTRANSFORMFEEDBACKVARYINGNV, (GLuint program, GLuint index, GLint * location)) \
  CONST(GL_BACK_PRIMARY_COLOR_NV, 0x8C77) \
  CONST(GL_BACK_SECONDARY_COLOR_NV, 0x8C78) \
  CONST(GL_TEXTURE_COORD_NV, 0x8C79) \
  CONST(GL_CLIP_DISTANCE_NV, 0x8C7A) \
  CONST(GL_VERTEX_ID_NV, 0x8C7B) \
  CONST(GL_PRIMITIVE_ID_NV, 0x8C7C) \
  CONST(GL_GENERIC_ATTRIB_NV, 0x8C7D) \
  CONST(GL_TRANSFORM_FEEDBACK_ATTRIBS_NV, 0x8C7E) \
  CONST(GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV, 0x8C7F) \
  CONST(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV, 0x8C80) \
  CONST(GL_ACTIVE_VARYINGS_NV, 0x8C81) \
  CONST(GL_ACTIVE_VARYING_MAX_LENGTH_NV, 0x8C82) \
  CONST(GL_TRANSFORM_FEEDBACK_VARYINGS_NV, 0x8C83) \
  CONST(GL_TRANSFORM_FEEDBACK_BUFFER_START_NV, 0x8C84) \
  CONST(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV, 0x8C85) \
  CONST(GL_TRANSFORM_FEEDBACK_RECORD_NV, 0x8C86) \
  CONST(GL_PRIMITIVES_GENERATED_NV, 0x8C87) \
  CONST(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV, 0x8C88) \
  CONST(GL_RASTERIZER_DISCARD_NV, 0x8C89) \
  CONST(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV, 0x8C8A) \
  CONST(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV, 0x8C8B) \
  CONST(GL_INTERLEAVED_ATTRIBS_NV, 0x8C8C) \
  CONST(GL_SEPARATE_ATTRIBS_NV, 0x8C8D) \
  CONST(GL_TRANSFORM_FEEDBACK_BUFFER_NV, 0x8C8E) \
  CONST(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV, 0x8C8F) \
  END()
#else
#define EXTENSION_GL_NV_transform_feedback(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_geometry_program4
#define GL_NV_geometry_program4 1
#define EXTENSION_GL_NV_geometry_program4(NAME, FUNC, CONST, END) \
  NAME(GL_NV_geometry_program4) \
  FUNC(void, glProgramVertexLimitNV, GLPROGRAMVERTEXLIMITNV, (GLenum target, GLint limit)) \
  CONST(GL_GEOMETRY_PROGRAM_NV, 0x8C26) \
  CONST(GL_MAX_PROGRAM_OUTPUT_VERTICES_NV, 0x8C27) \
  CONST(GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV, 0x8C28) \
  END()
#else
#define EXTENSION_GL_NV_geometry_program4(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_gpu_program4
#define GL_NV_gpu_program4 1
#define EXTENSION_GL_NV_gpu_program4(NAME, FUNC, CONST, END) \
  NAME(GL_NV_gpu_program4) \
  FUNC(void, glProgramLocalParameterI4iNV, GLPROGRAMLOCALPARAMETERI4INV, (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)) \
  FUNC(void, glProgramLocalParameterI4ivNV, GLPROGRAMLOCALPARAMETERI4IVNV, (GLenum target, GLuint index, const GLint * params)) \
  FUNC(void, glProgramLocalParametersI4ivNV, GLPROGRAMLOCALPARAMETERSI4IVNV, (GLenum target, GLuint index, GLsizei count, const GLint * params)) \
  FUNC(void, glProgramLocalParameterI4uiNV, GLPROGRAMLOCALPARAMETERI4UINV, (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
  FUNC(void, glProgramLocalParameterI4uivNV, GLPROGRAMLOCALPARAMETERI4UIVNV, (GLenum target, GLuint index, const GLuint * params)) \
  FUNC(void, glProgramLocalParametersI4uivNV, GLPROGRAMLOCALPARAMETERSI4UIVNV, (GLenum target, GLuint index, GLsizei count, const GLuint * params)) \
  FUNC(void, glProgramEnvParameterI4iNV, GLPROGRAMENVPARAMETERI4INV, (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)) \
  FUNC(void, glProgramEnvParameterI4ivNV, GLPROGRAMENVPARAMETERI4IVNV, (GLenum target, GLuint index, const GLint * params)) \
  FUNC(void, glProgramEnvParametersI4ivNV, GLPROGRAMENVPARAMETERSI4IVNV, (GLenum target, GLuint index, GLsizei count, const GLint * params)) \
  FUNC(void, glProgramEnvParameterI4uiNV, GLPROGRAMENVPARAMETERI4UINV, (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
  FUNC(void, glProgramEnvParameterI4uivNV, GLPROGRAMENVPARAMETERI4UIVNV, (GLenum target, GLuint index, const GLuint * params)) \
  FUNC(void, glProgramEnvParametersI4uivNV, GLPROGRAMENVPARAMETERSI4UIVNV, (GLenum target, GLuint index, GLsizei count, const GLuint * params)) \
  FUNC(void, glGetProgramLocalParameterIivNV, GLGETPROGRAMLOCALPARAMETERIIVNV, (GLenum target, GLuint index, GLint * params)) \
  FUNC(void, glGetProgramLocalParameterIuivNV, GLGETPROGRAMLOCALPARAMETERIUIVNV, (GLenum target, GLuint index, GLuint * params)) \
  FUNC(void, glGetProgramEnvParameterIivNV, GLGETPROGRAMENVPARAMETERIIVNV, (GLenum target, GLuint index, GLint * params)) \
  FUNC(void, glGetProgramEnvParameterIuivNV, GLGETPROGRAMENVPARAMETERIUIVNV, (GLenum target, GLuint index, GLuint * params)) \
  CONST(GL_MIN_PROGRAM_TEXEL_OFFSET_NV, 0x8904) \
  CONST(GL_MAX_PROGRAM_TEXEL_OFFSET_NV, 0x8905) \
  CONST(GL_PROGRAM_ATTRIB_COMPONENTS_NV, 0x8906) \
  CONST(GL_PROGRAM_RESULT_COMPONENTS_NV, 0x8907) \
  CONST(GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV, 0x8908) \
  CONST(GL_MAX_PROGRAM_RESULT_COMPONENTS_NV, 0x8909) \
  CONST(GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV, 0x8DA5) \
  CONST(GL_MAX_PROGRAM_GENERIC_RESULTS_NV, 0x8DA6) \
  END()
#else
#define EXTENSION_GL_NV_gpu_program4(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_framebuffer_multisample_coverage
#define GL_NV_framebuffer_multisample_coverage 1
#define EXTENSION_GL_NV_framebuffer_multisample_coverage(NAME, FUNC, CONST, END) \
  NAME(GL_NV_framebuffer_multisample_coverage) \
  FUNC(void, glRenderbufferStorageMultisampleCoverageNV, GLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENV, (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)) \
  CONST(GL_RENDERBUFFER_COVERAGE_SAMPLES_NV, 0x8CAB) \
  CONST(GL_RENDERBUFFER_COLOR_SAMPLES_NV, 0x8E10) \
  CONST(GL_MAX_RENDERBUFFER_COVERAGE_SAMPLES_NV, 0x8D57) \
  CONST(GL_MAX_RENDERBUFFER_COLOR_SAMPLES_NV, 0x8E11) \
  CONST(GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV, 0x8E12) \
  CONST(GL_MULTISAMPLE_COVERAGE_MODES_NV, 0x8E13) \
  END()
#else
#define EXTENSION_GL_NV_framebuffer_multisample_coverage(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_framebuffer_multisample
#define GL_EXT_framebuffer_multisample 1
#define EXTENSION_GL_EXT_framebuffer_multisample(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_framebuffer_multisample) \
  FUNC(void, glRenderbufferStorageMultisampleEXT, GLRENDERBUFFERSTORAGEMULTISAMPLEEXT, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)) \
  CONST(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT, 0x8D56) \
  CONST(GL_MAX_SAMPLES_EXT, 0x8D57) \
  CONST(GL_RENDERBUFFER_SAMPLES_EXT, 0x8CAB) \
  END()
#else
#define EXTENSION_GL_EXT_framebuffer_multisample(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_framebuffer_blit
#define GL_EXT_framebuffer_blit 1
#define EXTENSION_GL_EXT_framebuffer_blit(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_framebuffer_blit) \
  FUNC(void, glBlitFramebufferEXT, GLBLITFRAMEBUFFEREXT, (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)) \
  CONST(GL_READ_FRAMEBUFFER_EXT, 0x8CA8) \
  CONST(GL_DRAW_FRAMEBUFFER_EXT, 0x8CA9) \
  CONST(GL_DRAW_FRAMEBUFFER_BINDING_EXT, 0x8CA6) \
  CONST(GL_READ_FRAMEBUFFER_BINDING_EXT, 0x8CAA) \
  END()
#else
#define EXTENSION_GL_EXT_framebuffer_blit(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_compression_rgtc
#define GL_EXT_texture_compression_rgtc 1
#define EXTENSION_GL_EXT_texture_compression_rgtc(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_compression_rgtc) \
  CONST(GL_COMPRESSED_RED_RGTC1_EXT, 0x8DBB) \
  CONST(GL_COMPRESSED_SIGNED_RED_RGTC1_EXT, 0x8DBC) \
  CONST(GL_COMPRESSED_RED_GREEN_RGTC2_EXT, 0x8DBD) \
  CONST(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, 0x8DBE) \
  END()
#else
#define EXTENSION_GL_EXT_texture_compression_rgtc(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_color_matrix
#define GL_EXT_color_matrix 1
#define EXTENSION_GL_EXT_color_matrix(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_color_matrix) \
  END()
#else
#define EXTENSION_GL_EXT_color_matrix(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_texture_select
#define GL_SGIX_texture_select 1
#define EXTENSION_GL_SGIX_texture_select(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_texture_select) \
  END()
#else
#define EXTENSION_GL_SGIX_texture_select(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_INGR_blend_func_separate
#define GL_INGR_blend_func_separate 1
#define EXTENSION_GL_INGR_blend_func_separate(NAME, FUNC, CONST, END) \
  NAME(GL_INGR_blend_func_separate) \
  FUNC(void, glBlendFuncSeparateINGR, GLBLENDFUNCSEPARATEINGR, (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)) \
  END()
#else
#define EXTENSION_GL_INGR_blend_func_separate(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_depth_pass_instrument
#define GL_SGIX_depth_pass_instrument 1
#define EXTENSION_GL_SGIX_depth_pass_instrument(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_depth_pass_instrument) \
  END()
#else
#define EXTENSION_GL_SGIX_depth_pass_instrument(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_igloo_interface
#define GL_SGIX_igloo_interface 1
#define EXTENSION_GL_SGIX_igloo_interface(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_igloo_interface) \
  FUNC(void, glIglooInterfaceSGIX, GLIGLOOINTERFACESGIX, (GLenum pname, const GLvoid * params)) \
  END()
#else
#define EXTENSION_GL_SGIX_igloo_interface(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_draw_buffers2
#define GL_EXT_draw_buffers2 1
#define EXTENSION_GL_EXT_draw_buffers2(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_draw_buffers2) \
  FUNC(void, glColorMaskIndexedEXT, GLCOLORMASKINDEXEDEXT, (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)) \
  FUNC(void, glGetBooleanIndexedvEXT, GLGETBOOLEANINDEXEDVEXT, (GLenum target, GLuint index, GLboolean * data)) \
  FUNC(void, glGetIntegerIndexedvEXT, GLGETINTEGERINDEXEDVEXT, (GLenum target, GLuint index, GLint * data)) \
  FUNC(void, glEnableIndexedEXT, GLENABLEINDEXEDEXT, (GLenum target, GLuint index)) \
  FUNC(void, glDisableIndexedEXT, GLDISABLEINDEXEDEXT, (GLenum target, GLuint index)) \
  FUNC(GLboolean, glIsEnabledIndexedEXT, GLISENABLEDINDEXEDEXT, (GLenum target, GLuint index)) \
  END()
#else
#define EXTENSION_GL_EXT_draw_buffers2(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_NV_parameter_buffer_object
#define GL_NV_parameter_buffer_object 1
#define EXTENSION_GL_NV_parameter_buffer_object(NAME, FUNC, CONST, END) \
  NAME(GL_NV_parameter_buffer_object) \
  FUNC(void, glProgramBufferParametersfvNV, GLPROGRAMBUFFERPARAMETERSFVNV, (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat * params)) \
  FUNC(void, glProgramBufferParametersIivNV, GLPROGRAMBUFFERPARAMETERSIIVNV, (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint * params)) \
  FUNC(void, glProgramBufferParametersIuivNV, GLPROGRAMBUFFERPARAMETERSIUIVNV, (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint * params)) \
  END()
#else
#define EXTENSION_GL_NV_parameter_buffer_object(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_draw_instanced
#define GL_EXT_draw_instanced 1
#define EXTENSION_GL_EXT_draw_instanced(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_draw_instanced) \
  FUNC(void, glDrawArraysInstancedEXT, GLDRAWARRAYSINSTANCEDEXT, (GLenum mode, GLint start, GLsizei count, GLsizei primcount)) \
  FUNC(void, glDrawElementsInstancedEXT, GLDRAWELEMENTSINSTANCEDEXT, (GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount)) \
  END()
#else
#define EXTENSION_GL_EXT_draw_instanced(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_fragment_lighting
#define GL_EXT_fragment_lighting 1
#define EXTENSION_GL_EXT_fragment_lighting(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_fragment_lighting) \
  FUNC(GLvoid, glFragmentLightModeliEXT, GLFRAGMENTLIGHTMODELIEXT, (GLenum pname, GLint param)) \
  FUNC(GLvoid, glFragmentLightModelfEXT, GLFRAGMENTLIGHTMODELFEXT, (GLenum pname, GLfloat param)) \
  FUNC(GLvoid, glFragmentLightModelivEXT, GLFRAGMENTLIGHTMODELIVEXT, (GLenum pname, GLint * params)) \
  FUNC(GLvoid, glFragmentLightModelfvEXT, GLFRAGMENTLIGHTMODELFVEXT, (GLenum pname, GLfloat * params)) \
  FUNC(GLvoid, glFragmentLightiEXT, GLFRAGMENTLIGHTIEXT, (GLenum light, GLenum pname, GLint param)) \
  FUNC(GLvoid, glFragmentLightfEXT, GLFRAGMENTLIGHTFEXT, (GLenum light, GLenum pname, GLfloat param)) \
  FUNC(GLvoid, glFragmentLightivEXT, GLFRAGMENTLIGHTIVEXT, (GLenum light, GLenum pname, GLint * params)) \
  FUNC(GLvoid, glFragmentLightfvEXT, GLFRAGMENTLIGHTFVEXT, (GLenum light, GLenum pname, GLfloat * params)) \
  FUNC(GLvoid, glGetFragmentLightivEXT, GLGETFRAGMENTLIGHTIVEXT, (GLenum light, GLenum pname, GLint * params)) \
  FUNC(GLvoid, glGetFragmentLightfvEXT, GLGETFRAGMENTLIGHTFVEXT, (GLenum light, GLenum pname, GLfloat * params)) \
  FUNC(GLvoid, glFragmentMaterialfEXT, GLFRAGMENTMATERIALFEXT, (GLenum face, GLenum pname, const GLfloat param)) \
  FUNC(GLvoid, glFragmentMaterialiEXT, GLFRAGMENTMATERIALIEXT, (GLenum face, GLenum pname, const GLint param)) \
  FUNC(GLvoid, glFragmentMaterialfvEXT, GLFRAGMENTMATERIALFVEXT, (GLenum face, GLenum pname, const GLfloat * params)) \
  FUNC(GLvoid, glFragmentMaterialivEXT, GLFRAGMENTMATERIALIVEXT, (GLenum face, GLenum pname, const GLint * params)) \
  FUNC(GLvoid, glFragmentColorMaterialEXT, GLFRAGMENTCOLORMATERIALEXT, (GLenum face, GLenum mode)) \
  FUNC(GLvoid, glGetFragmentMaterialfvEXT, GLGETFRAGMENTMATERIALFVEXT, (GLenum face, GLenum pname, const GLfloat * params)) \
  FUNC(GLvoid, glGetFragmentMaterialivEXT, GLGETFRAGMENTMATERIALIVEXT, (GLenum face, GLenum pname, const GLint * params)) \
  FUNC(GLvoid, glLightEnviEXT, GLLIGHTENVIEXT, (GLenum pname, GLint param)) \
  CONST(GL_FRAGMENT_LIGHTING_EXT, 0x8400) \
  CONST(GL_FRAGMENT_COLOR_MATERIAL_EXT, 0x8401) \
  CONST(GL_FRAGMENT_COLOR_MATERIAL_FACE_EXT, 0x8402) \
  CONST(GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_EXT, 0x8403) \
  CONST(GL_MAX_FRAGMENT_LIGHTS_EXT, 0x8404) \
  CONST(GL_MAX_ACTIVE_LIGHTS_EXT, 0x8405) \
  CONST(GL_CURRENT_RASTER_NORMAL_EXT, 0x8406) \
  CONST(GL_LIGHT_ENV_MODE_EXT, 0x8407) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT, 0x8408) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT, 0x8409) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_AMBIENT_EXT, 0x840A) \
  CONST(GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT, 0x840B) \
  CONST(GL_FRAGMENT_LIGHT0_EXT, 0x840C) \
  CONST(GL_FRAGMENT_LIGHT7_EXT, 0x8413) \
  END()
#else
#define EXTENSION_GL_EXT_fragment_lighting(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_packed_depth_stencil
#define GL_EXT_packed_depth_stencil 1
#define EXTENSION_GL_EXT_packed_depth_stencil(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_packed_depth_stencil) \
  CONST(GL_DEPTH_STENCIL_EXT, 0x84F9) \
  CONST(GL_UNSIGNED_INT_24_8_EXT, 0x84FA) \
  CONST(GL_DEPTH24_STENCIL8_EXT, 0x88F0) \
  CONST(GL_TEXTURE_STENCIL_SIZE_EXT, 0x88F1) \
  END()
#else
#define EXTENSION_GL_EXT_packed_depth_stencil(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_scene_marker
#define GL_EXT_scene_marker 1
#define EXTENSION_GL_EXT_scene_marker(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_scene_marker) \
  FUNC(GLvoid, glBeginSceneEXT, GLBEGINSCENEEXT, ()) \
  FUNC(GLvoid, glEndSceneEXT, GLENDSCENEEXT, ()) \
  END()
#else
#define EXTENSION_GL_EXT_scene_marker(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_stencil_clear_tag
#define GL_EXT_stencil_clear_tag 1
#define EXTENSION_GL_EXT_stencil_clear_tag(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_stencil_clear_tag) \
  CONST(GL_STENCIL_TAG_BITS_EXT, 0x88F2) \
  CONST(GL_STENCIL_CLEAR_TAG_VALUE_EXT, 0x88F3) \
  END()
#else
#define EXTENSION_GL_EXT_stencil_clear_tag(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_env
#define GL_EXT_texture_env 1
#define EXTENSION_GL_EXT_texture_env(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_env) \
  CONST(GL_TEXTURE_ENV0_EXT, 0) \
  CONST(GL_TEXTURE_ENV_MODE_ALPHA_EXT, 0) \
  CONST(GL_ENV_COPY_EXT, 0) \
  CONST(GL_ENV_REPLACE_EXT, 0) \
  CONST(GL_ENV_MODULATE_EXT, 0) \
  CONST(GL_ENV_ADD_EXT, 0) \
  CONST(GL_ENV_SUBTRACT_EXT, 0) \
  CONST(GL_ENV_REVERSE_SUBTRACT_EXT, 0) \
  CONST(GL_ENV_BLEND_EXT, 0) \
  CONST(GL_ENV_REVERSE_BLEND_EXT, 0) \
  CONST(GL_TEXTURE_ENV_SHIFT_EXT, 0) \
  END()
#else
#define EXTENSION_GL_EXT_texture_env(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_EXT_texture_sRGB
#define GL_EXT_texture_sRGB 1
#define EXTENSION_GL_EXT_texture_sRGB(NAME, FUNC, CONST, END) \
  NAME(GL_EXT_texture_sRGB) \
  CONST(GL_SRGB_EXT, 0x8C40) \
  CONST(GL_SRGB8_EXT, 0x8C41) \
  CONST(GL_SRGB_ALPHA_EXT, 0x8C42) \
  CONST(GL_SRGB8_ALPHA8_EXT, 0x8C43) \
  CONST(GL_SLUMINANCE_ALPHA_EXT, 0x8C44) \
  CONST(GL_SLUMINANCE8_ALPHA8_EXT, 0x8C45) \
  CONST(GL_SLUMINANCE_EXT, 0x8C46) \
  CONST(GL_SLUMINANCE8_EXT, 0x8C47) \
  CONST(GL_COMPRESSED_SRGB_EXT, 0x8C48) \
  CONST(GL_COMPRESSED_SRGB_ALPHA_EXT, 0x8C49) \
  CONST(GL_COMPRESSED_SLUMINANCE_EXT, 0x8C4A) \
  CONST(GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, 0x8C4B) \
  CONST(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 0x8C4C) \
  CONST(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0x8C4D) \
  CONST(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0x8C4E) \
  CONST(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0x8C4F) \
  END()
#else
#define EXTENSION_GL_EXT_texture_sRGB(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_IBM_static_data
#define GL_IBM_static_data 1
#define EXTENSION_GL_IBM_static_data(NAME, FUNC, CONST, END) \
  NAME(GL_IBM_static_data) \
  CONST(GL_ALL_STATIC_DATA_IBM, 103060) \
  CONST(GL_STATIC_VERTEX_ARRAY_IBM, 103061) \
  END()
#else
#define EXTENSION_GL_IBM_static_data(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_MESAX_texture_stack
#define GL_MESAX_texture_stack 1
#define EXTENSION_GL_MESAX_texture_stack(NAME, FUNC, CONST, END) \
  NAME(GL_MESAX_texture_stack) \
  CONST(GL_TEXTURE_1D_STACK_MESAX, 0x8759) \
  CONST(GL_TEXTURE_2D_STACK_MESAX, 0x875A) \
  CONST(GL_PROXY_TEXTURE_1D_STACK_MESAX, 0x875B) \
  CONST(GL_PROXY_TEXTURE_2D_STACK_MESAX, 0x875C) \
  CONST(GL_TEXTURE_1D_STACK_BINDING_MESAX, 0x875D) \
  CONST(GL_TEXTURE_2D_STACK_BINDING_MESAX, 0x875E) \
  END()
#else
#define EXTENSION_GL_MESAX_texture_stack(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_OES_byte_coordinates
#define GL_OES_byte_coordinates 1
#define EXTENSION_GL_OES_byte_coordinates(NAME, FUNC, CONST, END) \
  NAME(GL_OES_byte_coordinates) \
  CONST(GL_BYTE, 0x1400) \
  END()
#else
#define EXTENSION_GL_OES_byte_coordinates(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_OES_compressed_paletted_texture
#define GL_OES_compressed_paletted_texture 1
#define EXTENSION_GL_OES_compressed_paletted_texture(NAME, FUNC, CONST, END) \
  NAME(GL_OES_compressed_paletted_texture) \
  CONST(GL_PALETTE4_RGB8_OES, 0x8B90) \
  CONST(GL_PALETTE4_RGBA8_OES, 0x8B91) \
  CONST(GL_PALETTE4_R5_G6_B5_OES, 0x8B92) \
  CONST(GL_PALETTE4_RGBA4_OES, 0x8B93) \
  CONST(GL_PALETTE4_RGB5_A1_OES, 0x8B94) \
  CONST(GL_PALETTE8_RGB8_OES, 0x8B95) \
  CONST(GL_PALETTE8_RGBA8_OES, 0x8B96) \
  CONST(GL_PALETTE8_R5_G6_B5_OES, 0x8B97) \
  CONST(GL_PALETTE8_RGBA4_OES, 0x8B98) \
  CONST(GL_PALETTE8_RGB5_A1_OES, 0x8B99) \
  END()
#else
#define EXTENSION_GL_OES_compressed_paletted_texture(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_OES_single_precision
#define GL_OES_single_precision 1
#define EXTENSION_GL_OES_single_precision(NAME, FUNC, CONST, END) \
  NAME(GL_OES_single_precision) \
  FUNC(GLvoid, glDepthRangefOES, GLDEPTHRANGEFOES, (GLclampf n, GLclampf f)) \
  FUNC(GLvoid, glFrustumfOES, GLFRUSTUMFOES, (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)) \
  FUNC(GLvoid, glOrthofOES, GLORTHOFOES, (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)) \
  FUNC(GLvoid, glClipPlanefOES, GLCLIPPLANEFOES, (GLenum plane, const GLfloat* equation)) \
  FUNC(GLvoid, glGetClipPlanefOES, GLGETCLIPPLANEFOES, (GLenum plane, GLfloat* equation)) \
  FUNC(GLvoid, glClearDepthfOES, GLCLEARDEPTHFOES, (GLclampd depth)) \
  END()
#else
#define EXTENSION_GL_OES_single_precision(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_pixel_texture_bits
#define GL_SGIX_pixel_texture_bits 1
#define EXTENSION_GL_SGIX_pixel_texture_bits(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_pixel_texture_bits) \
  END()
#else
#define EXTENSION_GL_SGIX_pixel_texture_bits(NAME, FUNC, CONST, END)
#endif
    

#ifndef GL_SGIX_texture_range
#define GL_SGIX_texture_range 1
#define EXTENSION_GL_SGIX_texture_range(NAME, FUNC, CONST, END) \
  NAME(GL_SGIX_texture_range) \
  CONST(GL_RGB_SIGNED_SGIX, 0x85E0) \
  CONST(GL_RGBA_SIGNED_SGIX, 0x85E1) \
  CONST(GL_ALPHA_SIGNED_SGIX, 0x85E2) \
  CONST(GL_LUMINANCE_SIGNED_SGIX, 0x85E3) \
  CONST(GL_INTENSITY_SIGNED_SGIX, 0x85E4) \
  CONST(GL_LUMINANCE_ALPHA_SIGNED_SGIX, 0x85E5) \
  CONST(GL_RGB16_SIGNED_SGIX, 0x85E6) \
  CONST(GL_RGBA16_SIGNED_SGIX, 0x85E7) \
  CONST(GL_ALPHA16_SIGNED_SGIX, 0x85E8) \
  CONST(GL_LUMINANCE16_SIGNED_SGIX, 0x85E9) \
  CONST(GL_INTENSITY16_SIGNED_SGIX, 0x85EA) \
  CONST(GL_LUMINANCE16_ALPHA16_SIGNED_SGIX, 0x85EB) \
  CONST(GL_RGB_EXTENDED_RANGE_SGIX, 0x85EC) \
  CONST(GL_RGBA_EXTENDED_RANGE_SGIX, 0x85ED) \
  CONST(GL_ALPHA_EXTENDED_RANGE_SGIX, 0x85EE) \
  CONST(GL_LUMINANCE_EXTENDED_RANGE_SGIX, 0x85EF) \
  CONST(GL_INTENSITY_EXTENDED_RANGE_SGIX, 0x85F0) \
  CONST(GL_LUMINANCE_ALPHA_EXTENDED_RANGE_SGIX, 0x85F1) \
  CONST(GL_RGB16_EXTENDED_RANGE_SGIX, 0x85F2) \
  CONST(GL_RGBA16_EXTENDED_RANGE_SGIX, 0x85F3) \
  CONST(GL_ALPHA16_EXTENDED_RANGE_SGIX, 0x85F4) \
  CONST(GL_LUMINANCE16_EXTENDED_RANGE_SGIX, 0x85F5) \
  CONST(GL_INTENSITY16_EXTENDED_RANGE_SGIX, 0x85F6) \
  CONST(GL_LUMINANCE16_ALPHA16_EXTENDED_RANGE_SGIX, 0x85F7) \
  CONST(GL_MIN_LUMINANCE_SGIS, 0x85F8) \
  CONST(GL_MAX_LUMINANCE_SGIS, 0x85F9) \
  CONST(GL_MIN_INTENSITY_SGIS, 0x85FA) \
  CONST(GL_MAX_INTENSITY_SGIS, 0x85FB) \
  END()
#else
#define EXTENSION_GL_SGIX_texture_range(NAME, FUNC, CONST, END)
#endif
    

#define ALL_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_imaging(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_5(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_2_0(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_2_1(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multitexture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_transpose_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_add(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_cube_map(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_compression(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_border_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_blend(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_matrix_palette(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_combine(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_crossbar(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_dot3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_mirrored_repeat(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_depth_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow_ambient(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_window_pos(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_occlusion_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shader_objects(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shading_language_100(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_non_power_of_two(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_sprite(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_draw_buffers(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_rectangle(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_color_buffer_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_half_float_pixel(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_pixel_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_abgr(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_polygon_offset(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture3D(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_texture_filter4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_subtexture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_copy_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_histogram(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_convolution(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGI_color_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGI_color_table(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_pixel_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_pixel_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_texture4D(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGI_texture_color_table(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_cmyka(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_detail_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_sharpen_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_pixels(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_texture_lod(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_rescale_normal(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_misc_attribute(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_generate_mipmap(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_clipmap(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_texture_edge_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_texture_border_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_minmax(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_subtract(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_logic_op(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_interlace(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_pixel_tiles(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_texture_select(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_sprite(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_texture_multi_buffer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_instruments(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_texture_scale_bias(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_framezoom(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_tag_sample_buffer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_FfdMaskSGIX(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_polynomial_ffd(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_reference_plane(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_flush_raster(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_depth_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_fog_function(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_fog_offset(NAME, FUNC, CONST, END) \
  EXTENSION_GL_HP_image_transform(NAME, FUNC, CONST, END) \
  EXTENSION_GL_HP_convolution_border_modes(NAME, FUNC, CONST, END) \
  EXTENSION_GL_INGR_palette_buffer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_texture_add_env(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_color_subtable(NAME, FUNC, CONST, END) \
  EXTENSION_GL_PGI_vertex_hints(NAME, FUNC, CONST, END) \
  EXTENSION_GL_PGI_misc_hints(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_paletted_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_clip_volume_hint(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_list_priority(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_ir_instrument1(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_calligraphic_fragment(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_texture_lod_bias(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_shadow_ambient(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_material(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_func(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_array_formats(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_compiled_vertex_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_cull_vertex(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_ycrcb(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_fragment_lighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_IBM_rasterpos_clip(NAME, FUNC, CONST, END) \
  EXTENSION_GL_HP_texture_lighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_range_elements(NAME, FUNC, CONST, END) \
  EXTENSION_GL_WIN_phong_shading(NAME, FUNC, CONST, END) \
  EXTENSION_GL_WIN_specular_fog(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_light_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_blend_alpha_minmax(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_impact_pixel_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_bgra(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_async(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_async_pixel(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_async_histogram(NAME, FUNC, CONST, END) \
  EXTENSION_GL_INTEL_texture_scissor(NAME, FUNC, CONST, END) \
  EXTENSION_GL_INTEL_parallel_arrays(NAME, FUNC, CONST, END) \
  EXTENSION_GL_HP_occlusion_test(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_transform(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_transform_color_table(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_shared_texture_palette(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_separate_specular_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_secondary_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_perturb_normal(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_multi_draw_arrays(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_fog_coord(NAME, FUNC, CONST, END) \
  EXTENSION_GL_REND_screen_coordinates(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_coordinate_frame(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_combine(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_specular_vector(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_transform_hint(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_fog_scale(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SUNX_constant_data(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SUN_global_alpha(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SUN_triangle_list(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SUN_vertex(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_func_separate(NAME, FUNC, CONST, END) \
  EXTENSION_GL_INGR_color_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_INGR_interlace_read(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_wrap(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_422_pixels(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texgen_reflection(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_cube_map(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SUN_convolution_border_modes(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_add(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_lod_bias(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_filter_anisotropic(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_weighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_light_max_exponent(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_vertex_array_range(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_register_combiners(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_fog_distance(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texgen_emboss(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_blend_square(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texture_env_combine4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_MESA_resize_buffers(NAME, FUNC, CONST, END) \
  EXTENSION_GL_MESA_window_pos(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_s3tc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_IBM_cull_vertex(NAME, FUNC, CONST, END) \
  EXTENSION_GL_IBM_multimode_draw_arrays(NAME, FUNC, CONST, END) \
  EXTENSION_GL_IBM_vertex_array_lists(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_subsample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_ycrcb_subsample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_ycrcba(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGI_depth_pass_instrument(NAME, FUNC, CONST, END) \
  EXTENSION_GL_3DFX_texture_compression_FXT1(NAME, FUNC, CONST, END) \
  EXTENSION_GL_3DFX_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_3DFX_tbuffer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_vertex_preclip(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_convolution_accuracy(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_resample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_point_line_texgen(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIS_texture_color_mask(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_dot3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_texture_mirror_once(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_fence(NAME, FUNC, CONST, END) \
  EXTENSION_GL_IBM_texture_mirrored_repeat(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_evaluators(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_packed_depth_stencil(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_register_combiners2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texture_compression_vtc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texture_rectangle(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texture_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texture_shader2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_vertex_array_range2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_vertex_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_texture_coordinate_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_scalebias_hint(NAME, FUNC, CONST, END) \
  EXTENSION_GL_OML_interlace(NAME, FUNC, CONST, END) \
  EXTENSION_GL_OML_subsample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_OML_resample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_copy_depth_to_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_envmap_bumpmap(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_fragment_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_pn_triangles(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_vertex_array_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_vertex_streams(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_element_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SUN_mesh_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SUN_slice_accum(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_multisample_filter_hint(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_depth_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_occlusion_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_point_sprite(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texture_shader3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_vertex_program1_1(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_shadow_funcs(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_two_side(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_text_fragment_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_client_storage(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_element_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_fence(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_vertex_array_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_vertex_array_range(NAME, FUNC, CONST, END) \
  EXTENSION_GL_APPLE_ycbcr_422(NAME, FUNC, CONST, END) \
  EXTENSION_GL_S3_s3tc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_draw_buffers(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_pixel_format_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_texture_env_combine3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_texture_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_float_buffer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_fragment_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_half_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_pixel_data_range(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_primitive_restart(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_texture_expand_normal(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_vertex_program2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_map_object_buffer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_separate_stencil(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ATI_vertex_attrib_array_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_OES_read_format(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_depth_bounds_test(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_mirror_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_equation_separate(NAME, FUNC, CONST, END) \
  EXTENSION_GL_MESA_pack_invert(NAME, FUNC, CONST, END) \
  EXTENSION_GL_MESA_ycbcr_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_fragment_program_option(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_fragment_program2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_vertex_program2_option(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_vertex_program3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_GREMEDY_string_marker(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_Cg_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_timer_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_gpu_shader4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_geometry_shader4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_bindable_uniform(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_sRGB(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_shared_exponent(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_integer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_depth_buffer_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_latc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_transform_feedback(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_geometry_program4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_gpu_program4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_framebuffer_multisample_coverage(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_blit(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_rgtc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_color_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_texture_select(NAME, FUNC, CONST, END) \
  EXTENSION_GL_INGR_blend_func_separate(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_depth_pass_instrument(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_igloo_interface(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_buffers2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_NV_parameter_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_instanced(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_fragment_lighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_depth_stencil(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_scene_marker(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_clear_tag(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_sRGB(NAME, FUNC, CONST, END) \
  EXTENSION_GL_IBM_static_data(NAME, FUNC, CONST, END) \
  EXTENSION_GL_MESAX_texture_stack(NAME, FUNC, CONST, END) \
  EXTENSION_GL_OES_byte_coordinates(NAME, FUNC, CONST, END) \
  EXTENSION_GL_OES_compressed_paletted_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_OES_single_precision(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_pixel_texture_bits(NAME, FUNC, CONST, END) \
  EXTENSION_GL_SGIX_texture_range(NAME, FUNC, CONST, END) \


#define ONLY_VERSION MAX_VERSION_EXTENSIONS
#define VERSION_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_5(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_2_0(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_2_1(NAME, FUNC, CONST, END) \


#define VERSION_1_2 VERSION_1_2_EXTENSIONS
#define VERSION_1_2_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \

    
#define VERSION_1_3 VERSION_1_3_EXTENSIONS
#define VERSION_1_3_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \

    
#define VERSION_1_4 VERSION_1_4_EXTENSIONS
#define VERSION_1_4_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END) \


#define VERSION_1_5 VERSION_1_5_EXTENSIONS
#define VERSION_1_5_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_5(NAME, FUNC, CONST, END) \


#define VERSION_2_0 VERSION_2_0_EXTENSIONS
#define VERSION_2_0_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_5(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_2_0(NAME, FUNC, CONST, END) \

    
#define VERSION_2_1 VERSION_2_1_EXTENSIONS
#define VERSION_2_1_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_1_5(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_2_0(NAME, FUNC, CONST, END) \
  EXTENSION_GL_VERSION_2_1(NAME, FUNC, CONST, END) \

    
#define ARB_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_imaging(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multitexture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_transpose_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_add(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_cube_map(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_compression(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_border_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_blend(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_matrix_palette(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_combine(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_crossbar(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_dot3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_mirrored_repeat(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_depth_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow_ambient(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_window_pos(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_occlusion_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shader_objects(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shading_language_100(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_non_power_of_two(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_sprite(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_draw_buffers(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_rectangle(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_color_buffer_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_half_float_pixel(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_pixel_buffer_object(NAME, FUNC, CONST, END) \

    
#define EXT_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_abgr(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_polygon_offset(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture3D(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_subtexture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_copy_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_histogram(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_convolution(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_cmyka(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_pixels(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_rescale_normal(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_misc_attribute(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_minmax(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_subtract(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_logic_op(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_color_subtable(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_paletted_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_clip_volume_hint(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_material(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_func(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_array_formats(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_compiled_vertex_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_cull_vertex(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_range_elements(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_light_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_bgra(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_transform(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_transform_color_table(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_shared_texture_palette(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_separate_specular_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_secondary_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_perturb_normal(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_multi_draw_arrays(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_fog_coord(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_coordinate_frame(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_combine(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_func_separate(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_wrap(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_422_pixels(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_cube_map(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_add(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_lod_bias(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_filter_anisotropic(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_weighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_s3tc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_dot3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_shadow_funcs(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_two_side(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_depth_bounds_test(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_mirror_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_equation_separate(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_Cg_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_timer_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_gpu_shader4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_geometry_shader4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_bindable_uniform(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_sRGB(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_shared_exponent(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_integer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_latc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_blit(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_rgtc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_color_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_buffers2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_instanced(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_fragment_lighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_depth_stencil(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_scene_marker(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_clear_tag(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_sRGB(NAME, FUNC, CONST, END) \

    
#define IMPORTANT_EXTENSIONS(NAME, FUNC, CONST, END) \
  MAX_VERSION_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_imaging(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multitexture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_transpose_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_add(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_cube_map(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_compression(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_border_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_blend(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_matrix_palette(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_combine(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_crossbar(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_dot3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_mirrored_repeat(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_depth_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow_ambient(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_window_pos(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_occlusion_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shader_objects(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shading_language_100(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_non_power_of_two(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_sprite(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_draw_buffers(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_rectangle(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_color_buffer_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_half_float_pixel(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_pixel_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_abgr(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_polygon_offset(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture3D(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_subtexture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_copy_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_histogram(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_convolution(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_cmyka(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_pixels(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_rescale_normal(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_misc_attribute(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_minmax(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_subtract(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_logic_op(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_color_subtable(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_paletted_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_clip_volume_hint(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_material(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_func(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_index_array_formats(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_compiled_vertex_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_cull_vertex(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_range_elements(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_light_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_bgra(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_transform(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_transform_color_table(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_shared_texture_palette(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_separate_specular_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_secondary_color(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_perturb_normal(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_multi_draw_arrays(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_fog_coord(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_coordinate_frame(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_combine(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_func_separate(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_wrap(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_422_pixels(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_cube_map(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_add(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_lod_bias(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_filter_anisotropic(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_weighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_s3tc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env_dot3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_vertex_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_shadow_funcs(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_two_side(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_depth_bounds_test(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_mirror_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_blend_equation_separate(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_pixel_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_Cg_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_timer_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_gpu_shader4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_geometry_shader4(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_bindable_uniform(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_sRGB(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_shared_exponent(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_array(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_integer(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_latc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_framebuffer_blit(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_compression_rgtc(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_color_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_buffers2(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_draw_instanced(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_fragment_lighting(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_packed_depth_stencil(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_scene_marker(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_stencil_clear_tag(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_env(NAME, FUNC, CONST, END) \
  EXTENSION_GL_EXT_texture_sRGB(NAME, FUNC, CONST, END) \

    
#define CRITICAL_EXTENSIONS(NAME, FUNC, CONST, END) \
  MAX_VERSION_EXTENSIONS(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_imaging(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multitexture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_transpose_matrix(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_multisample(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_add(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_cube_map(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_compression(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_border_clamp(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_parameters(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_blend(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_matrix_palette(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_combine(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_crossbar(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_env_dot3(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_mirrored_repeat(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_depth_texture(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shadow_ambient(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_window_pos(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_buffer_object(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_occlusion_query(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shader_objects(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_vertex_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_shader(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_shading_language_100(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_non_power_of_two(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_point_sprite(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_fragment_program_shadow(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_draw_buffers(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_rectangle(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_color_buffer_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_half_float_pixel(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_texture_float(NAME, FUNC, CONST, END) \
  EXTENSION_GL_ARB_pixel_buffer_object(NAME, FUNC, CONST, END) \




